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 const Type* PtrTy = PointerType::get(Type::Int8Ty);
1831 std::vector<const Type*> Params;
1832 if (Name == "llvm.va_start" || Name == "llvm.va_end") {
1833 if (Args.size() != 1)
1834 error("Invalid prototype for " + Name + " prototype");
1835 Params.push_back(PtrTy);
1836 const FunctionType *FTy =
1837 FunctionType::get(Type::VoidTy, Params, false);
1838 const PointerType *PFTy = PointerType::get(FTy);
1839 Value* Func = getVal(PFTy, ID);
1840 Args[0] = new BitCastInst(Args[0], PtrTy, makeNameUnique("va"), CurBB);
1841 return new CallInst(Func, &Args[0], Args.size());
1842 } else if (Name == "llvm.va_copy") {
1843 if (Args.size() != 2)
1844 error("Invalid prototype for " + Name + " prototype");
1845 Params.push_back(PtrTy);
1846 Params.push_back(PtrTy);
1847 const FunctionType *FTy =
1848 FunctionType::get(Type::VoidTy, Params, false);
1849 const PointerType *PFTy = PointerType::get(FTy);
1850 Value* Func = getVal(PFTy, ID);
1851 std::string InstName0(makeNameUnique("va0"));
1852 std::string InstName1(makeNameUnique("va1"));
1853 Args[0] = new BitCastInst(Args[0], PtrTy, InstName0, CurBB);
1854 Args[1] = new BitCastInst(Args[1], PtrTy, InstName1, CurBB);
1855 return new CallInst(Func, &Args[0], Args.size());
1862 const Type* upgradeGEPIndices(const Type* PTy,
1863 std::vector<ValueInfo> *Indices,
1864 std::vector<Value*> &VIndices,
1865 std::vector<Constant*> *CIndices = 0) {
1866 // Traverse the indices with a gep_type_iterator so we can build the list
1867 // of constant and value indices for use later. Also perform upgrades
1869 if (CIndices) CIndices->clear();
1870 for (unsigned i = 0, e = Indices->size(); i != e; ++i)
1871 VIndices.push_back((*Indices)[i].V);
1872 generic_gep_type_iterator<std::vector<Value*>::iterator>
1873 GTI = gep_type_begin(PTy, VIndices.begin(), VIndices.end()),
1874 GTE = gep_type_end(PTy, VIndices.begin(), VIndices.end());
1875 for (unsigned i = 0, e = Indices->size(); i != e && GTI != GTE; ++i, ++GTI) {
1876 Value *Index = VIndices[i];
1877 if (CIndices && !isa<Constant>(Index))
1878 error("Indices to constant getelementptr must be constants");
1879 // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte
1880 // struct indices to i32 struct indices with ZExt for compatibility.
1881 else if (isa<StructType>(*GTI)) { // Only change struct indices
1882 if (ConstantInt *CUI = dyn_cast<ConstantInt>(Index))
1883 if (CUI->getType()->getBitWidth() == 8)
1885 ConstantExpr::getCast(Instruction::ZExt, CUI, Type::Int32Ty);
1887 // Make sure that unsigned SequentialType indices are zext'd to
1888 // 64-bits if they were smaller than that because LLVM 2.0 will sext
1889 // all indices for SequentialType elements. We must retain the same
1890 // semantic (zext) for unsigned types.
1891 if (const IntegerType *Ity = dyn_cast<IntegerType>(Index->getType()))
1892 if (Ity->getBitWidth() < 64 && (*Indices)[i].S.isUnsigned()) {
1894 Index = ConstantExpr::getCast(Instruction::ZExt,
1895 cast<Constant>(Index), Type::Int64Ty);
1897 Index = CastInst::create(Instruction::ZExt, Index, Type::Int64Ty,
1898 makeNameUnique("gep"), CurBB);
1899 VIndices[i] = Index;
1902 // Add to the CIndices list, if requested.
1904 CIndices->push_back(cast<Constant>(Index));
1908 GetElementPtrInst::getIndexedType(PTy, &VIndices[0], VIndices.size(), true);
1910 error("Index list invalid for constant getelementptr");
1914 unsigned upgradeCallingConv(unsigned CC) {
1916 case OldCallingConv::C : return CallingConv::C;
1917 case OldCallingConv::CSRet : return CallingConv::C;
1918 case OldCallingConv::Fast : return CallingConv::Fast;
1919 case OldCallingConv::Cold : return CallingConv::Cold;
1920 case OldCallingConv::X86_StdCall : return CallingConv::X86_StdCall;
1921 case OldCallingConv::X86_FastCall: return CallingConv::X86_FastCall;
1927 Module* UpgradeAssembly(const std::string &infile, std::istream& in,
1928 bool debug, bool addAttrs)
1931 CurFilename = infile;
1934 AddAttributes = addAttrs;
1935 ObsoleteVarArgs = false;
1938 CurModule.CurrentModule = new Module(CurFilename);
1940 // Check to make sure the parser succeeded
1943 delete ParserResult;
1944 std::cerr << "llvm-upgrade: parse failed.\n";
1948 // Check to make sure that parsing produced a result
1949 if (!ParserResult) {
1950 std::cerr << "llvm-upgrade: no parse result.\n";
1954 // Reset ParserResult variable while saving its value for the result.
1955 Module *Result = ParserResult;
1958 //Not all functions use vaarg, so make a second check for ObsoleteVarArgs
1961 if ((F = Result->getFunction("llvm.va_start"))
1962 && F->getFunctionType()->getNumParams() == 0)
1963 ObsoleteVarArgs = true;
1964 if((F = Result->getFunction("llvm.va_copy"))
1965 && F->getFunctionType()->getNumParams() == 1)
1966 ObsoleteVarArgs = true;
1969 if (ObsoleteVarArgs && NewVarArgs) {
1970 error("This file is corrupt: it uses both new and old style varargs");
1974 if(ObsoleteVarArgs) {
1975 if(Function* F = Result->getFunction("llvm.va_start")) {
1976 if (F->arg_size() != 0) {
1977 error("Obsolete va_start takes 0 argument");
1983 //bar = alloca typeof(foo)
1987 const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
1988 const Type* ArgTy = F->getFunctionType()->getReturnType();
1989 const Type* ArgTyPtr = PointerType::get(ArgTy);
1990 Function* NF = cast<Function>(Result->getOrInsertFunction(
1991 "llvm.va_start", RetTy, ArgTyPtr, (Type *)0));
1993 while (!F->use_empty()) {
1994 CallInst* CI = cast<CallInst>(F->use_back());
1995 AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI);
1996 new CallInst(NF, bar, "", CI);
1997 Value* foo = new LoadInst(bar, "vastart.fix.2", CI);
1998 CI->replaceAllUsesWith(foo);
1999 CI->getParent()->getInstList().erase(CI);
2001 Result->getFunctionList().erase(F);
2004 if(Function* F = Result->getFunction("llvm.va_end")) {
2005 if(F->arg_size() != 1) {
2006 error("Obsolete va_end takes 1 argument");
2012 //bar = alloca 1 of typeof(foo)
2014 const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
2015 const Type* ArgTy = F->getFunctionType()->getParamType(0);
2016 const Type* ArgTyPtr = PointerType::get(ArgTy);
2017 Function* NF = cast<Function>(Result->getOrInsertFunction(
2018 "llvm.va_end", RetTy, ArgTyPtr, (Type *)0));
2020 while (!F->use_empty()) {
2021 CallInst* CI = cast<CallInst>(F->use_back());
2022 AllocaInst* bar = new AllocaInst(ArgTy, 0, "vaend.fix.1", CI);
2023 new StoreInst(CI->getOperand(1), bar, CI);
2024 new CallInst(NF, bar, "", CI);
2025 CI->getParent()->getInstList().erase(CI);
2027 Result->getFunctionList().erase(F);
2030 if(Function* F = Result->getFunction("llvm.va_copy")) {
2031 if(F->arg_size() != 1) {
2032 error("Obsolete va_copy takes 1 argument");
2037 //a = alloca 1 of typeof(foo)
2038 //b = alloca 1 of typeof(foo)
2043 const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
2044 const Type* ArgTy = F->getFunctionType()->getReturnType();
2045 const Type* ArgTyPtr = PointerType::get(ArgTy);
2046 Function* NF = cast<Function>(Result->getOrInsertFunction(
2047 "llvm.va_copy", RetTy, ArgTyPtr, ArgTyPtr, (Type *)0));
2049 while (!F->use_empty()) {
2050 CallInst* CI = cast<CallInst>(F->use_back());
2051 AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI);
2052 AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI);
2053 new StoreInst(CI->getOperand(1), b, CI);
2054 new CallInst(NF, a, b, "", CI);
2055 Value* foo = new LoadInst(a, "vacopy.fix.3", CI);
2056 CI->replaceAllUsesWith(foo);
2057 CI->getParent()->getInstList().erase(CI);
2059 Result->getFunctionList().erase(F);
2066 } // end llvm namespace
2068 using namespace llvm;
2072 /* Enabling traces. */
2077 /* Enabling verbose error messages. */
2078 #ifdef YYERROR_VERBOSE
2079 # undef YYERROR_VERBOSE
2080 # define YYERROR_VERBOSE 1
2082 # define YYERROR_VERBOSE 0
2085 /* Enabling the token table. */
2086 #ifndef YYTOKEN_TABLE
2087 # define YYTOKEN_TABLE 0
2090 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
2091 #line 1712 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
2092 typedef union YYSTYPE {
2093 llvm::Module *ModuleVal;
2094 llvm::Function *FunctionVal;
2095 std::pair<llvm::PATypeInfo, char*> *ArgVal;
2096 llvm::BasicBlock *BasicBlockVal;
2097 llvm::TermInstInfo TermInstVal;
2098 llvm::InstrInfo InstVal;
2099 llvm::ConstInfo ConstVal;
2100 llvm::ValueInfo ValueVal;
2101 llvm::PATypeInfo TypeVal;
2102 llvm::TypeInfo PrimType;
2103 llvm::PHIListInfo PHIList;
2104 std::list<llvm::PATypeInfo> *TypeList;
2105 std::vector<llvm::ValueInfo> *ValueList;
2106 std::vector<llvm::ConstInfo> *ConstVector;
2109 std::vector<std::pair<llvm::PATypeInfo,char*> > *ArgList;
2110 // Represent the RHS of PHI node
2111 std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable;
2113 llvm::GlobalValue::LinkageTypes Linkage;
2121 char *StrVal; // This memory is strdup'd!
2122 llvm::ValID ValIDVal; // strdup'd memory maybe!
2124 llvm::BinaryOps BinaryOpVal;
2125 llvm::TermOps TermOpVal;
2126 llvm::MemoryOps MemOpVal;
2127 llvm::OtherOps OtherOpVal;
2128 llvm::CastOps CastOpVal;
2129 llvm::ICmpInst::Predicate IPred;
2130 llvm::FCmpInst::Predicate FPred;
2131 llvm::Module::Endianness Endianness;
2133 /* Line 196 of yacc.c. */
2134 #line 2135 "UpgradeParser.tab.c"
2135 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
2136 # define YYSTYPE_IS_DECLARED 1
2137 # define YYSTYPE_IS_TRIVIAL 1
2142 /* Copy the second part of user declarations. */
2145 /* Line 219 of yacc.c. */
2146 #line 2147 "UpgradeParser.tab.c"
2148 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
2149 # define YYSIZE_T __SIZE_TYPE__
2151 #if ! defined (YYSIZE_T) && defined (size_t)
2152 # define YYSIZE_T size_t
2154 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
2155 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
2156 # define YYSIZE_T size_t
2158 #if ! defined (YYSIZE_T)
2159 # define YYSIZE_T unsigned int
2165 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
2166 # define YY_(msgid) dgettext ("bison-runtime", msgid)
2170 # define YY_(msgid) msgid
2174 #if ! defined (yyoverflow) || YYERROR_VERBOSE
2176 /* The parser invokes alloca or malloc; define the necessary symbols. */
2178 # ifdef YYSTACK_USE_ALLOCA
2179 # if YYSTACK_USE_ALLOCA
2181 # define YYSTACK_ALLOC __builtin_alloca
2183 # define YYSTACK_ALLOC alloca
2184 # if defined (__STDC__) || defined (__cplusplus)
2185 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
2186 # define YYINCLUDED_STDLIB_H
2192 # ifdef YYSTACK_ALLOC
2193 /* Pacify GCC's `empty if-body' warning. */
2194 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
2195 # ifndef YYSTACK_ALLOC_MAXIMUM
2196 /* The OS might guarantee only one guard page at the bottom of the stack,
2197 and a page size can be as small as 4096 bytes. So we cannot safely
2198 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
2199 to allow for a few compiler-allocated temporary stack slots. */
2200 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
2203 # define YYSTACK_ALLOC YYMALLOC
2204 # define YYSTACK_FREE YYFREE
2205 # ifndef YYSTACK_ALLOC_MAXIMUM
2206 # define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
2212 # define YYMALLOC malloc
2213 # if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
2214 && (defined (__STDC__) || defined (__cplusplus)))
2215 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
2219 # define YYFREE free
2220 # if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
2221 && (defined (__STDC__) || defined (__cplusplus)))
2222 void free (void *); /* INFRINGES ON USER NAME SPACE */
2229 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
2232 #if (! defined (yyoverflow) \
2233 && (! defined (__cplusplus) \
2234 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
2236 /* A type that is properly aligned for any stack member. */
2243 /* The size of the maximum gap between one aligned stack and the next. */
2244 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
2246 /* The size of an array large to enough to hold all stacks, each with
2248 # define YYSTACK_BYTES(N) \
2249 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
2250 + YYSTACK_GAP_MAXIMUM)
2252 /* Copy COUNT objects from FROM to TO. The source and destination do
2255 # if defined (__GNUC__) && 1 < __GNUC__
2256 # define YYCOPY(To, From, Count) \
2257 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
2259 # define YYCOPY(To, From, Count) \
2263 for (yyi = 0; yyi < (Count); yyi++) \
2264 (To)[yyi] = (From)[yyi]; \
2270 /* Relocate STACK from its old location to the new one. The
2271 local variables YYSIZE and YYSTACKSIZE give the old and new number of
2272 elements in the stack, and YYPTR gives the new location of the
2273 stack. Advance YYPTR to a properly aligned location for the next
2275 # define YYSTACK_RELOCATE(Stack) \
2278 YYSIZE_T yynewbytes; \
2279 YYCOPY (&yyptr->Stack, Stack, yysize); \
2280 Stack = &yyptr->Stack; \
2281 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
2282 yyptr += yynewbytes / sizeof (*yyptr); \
2288 #if defined (__STDC__) || defined (__cplusplus)
2289 typedef signed char yysigned_char;
2291 typedef short int yysigned_char;
2294 /* YYFINAL -- State number of the termination state. */
2296 /* YYLAST -- Last index in YYTABLE. */
2299 /* YYNTOKENS -- Number of terminals. */
2300 #define YYNTOKENS 166
2301 /* YYNNTS -- Number of nonterminals. */
2303 /* YYNRULES -- Number of rules. */
2304 #define YYNRULES 310
2305 /* YYNRULES -- Number of states. */
2306 #define YYNSTATES 606
2308 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
2309 #define YYUNDEFTOK 2
2310 #define YYMAXUTOK 406
2312 #define YYTRANSLATE(YYX) \
2313 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
2315 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
2316 static const unsigned char yytranslate[] =
2318 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2319 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2320 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2321 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2322 155, 156, 164, 2, 153, 2, 2, 2, 2, 2,
2323 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2324 160, 152, 161, 2, 2, 2, 2, 2, 2, 2,
2325 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2326 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2327 2, 157, 154, 159, 2, 2, 2, 2, 2, 165,
2328 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2329 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2330 158, 2, 2, 162, 2, 163, 2, 2, 2, 2,
2331 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2332 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2333 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2334 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2335 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2336 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2337 2, 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 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2342 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2343 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
2344 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2345 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
2346 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
2347 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
2348 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
2349 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2350 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
2351 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
2352 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
2353 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
2354 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2355 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
2356 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
2357 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
2358 145, 146, 147, 148, 149, 150, 151
2362 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
2364 static const unsigned short int yyprhs[] =
2366 0, 0, 3, 5, 7, 9, 11, 13, 15, 17,
2367 19, 21, 23, 25, 27, 29, 31, 33, 35, 37,
2368 39, 41, 43, 45, 47, 49, 51, 53, 55, 57,
2369 59, 61, 63, 65, 67, 69, 71, 73, 75, 77,
2370 79, 81, 83, 85, 87, 89, 91, 93, 95, 97,
2371 99, 101, 103, 105, 107, 109, 111, 113, 115, 117,
2372 119, 121, 123, 125, 127, 129, 131, 133, 135, 137,
2373 139, 141, 143, 145, 147, 149, 151, 153, 155, 157,
2374 159, 161, 164, 165, 167, 169, 171, 173, 175, 177,
2375 179, 180, 181, 183, 185, 187, 189, 191, 193, 196,
2376 197, 200, 201, 205, 208, 209, 211, 212, 216, 218,
2377 221, 223, 225, 227, 229, 231, 233, 235, 237, 239,
2378 241, 243, 245, 247, 249, 251, 253, 255, 257, 259,
2379 261, 264, 269, 275, 281, 285, 288, 294, 299, 302,
2380 304, 308, 310, 314, 316, 317, 322, 326, 330, 335,
2381 340, 344, 351, 357, 360, 363, 366, 369, 372, 375,
2382 378, 381, 384, 387, 394, 400, 409, 416, 423, 430,
2383 438, 446, 453, 460, 469, 478, 482, 484, 486, 488,
2384 490, 493, 496, 501, 504, 506, 511, 514, 519, 520,
2385 528, 529, 537, 538, 546, 547, 555, 559, 564, 565,
2386 567, 569, 571, 575, 579, 583, 587, 591, 595, 597,
2387 598, 600, 602, 604, 605, 608, 612, 614, 616, 620,
2388 622, 623, 632, 634, 636, 637, 642, 644, 646, 649,
2389 650, 652, 654, 655, 656, 662, 663, 665, 667, 669,
2390 671, 673, 675, 677, 679, 681, 685, 687, 693, 695,
2391 697, 699, 701, 704, 707, 710, 714, 717, 718, 720,
2392 722, 724, 727, 730, 734, 744, 754, 763, 777, 779,
2393 781, 788, 794, 797, 804, 812, 814, 818, 820, 821,
2394 824, 826, 832, 838, 844, 851, 858, 861, 866, 871,
2395 878, 883, 888, 893, 898, 905, 912, 915, 923, 925,
2396 928, 929, 931, 932, 936, 943, 947, 954, 957, 962,
2400 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
2401 static const short int yyrhs[] =
2403 200, 0, -1, 5, -1, 6, -1, 3, -1, 4,
2404 -1, 79, -1, 80, -1, 81, -1, 82, -1, 83,
2405 -1, 84, -1, 85, -1, 86, -1, 87, -1, 88,
2406 -1, 89, -1, 90, -1, 91, -1, 92, -1, 97,
2407 -1, 98, -1, 99, -1, 100, -1, 101, -1, 102,
2408 -1, 119, -1, 120, -1, 121, -1, 122, -1, 123,
2409 -1, 124, -1, 125, -1, 126, -1, 127, -1, 128,
2410 -1, 129, -1, 130, -1, 131, -1, 132, -1, 133,
2411 -1, 134, -1, 135, -1, 136, -1, 137, -1, 138,
2412 -1, 125, -1, 126, -1, 127, -1, 128, -1, 27,
2413 -1, 28, -1, 93, -1, 94, -1, 95, -1, 96,
2414 -1, 140, -1, 141, -1, 142, -1, 143, -1, 144,
2415 -1, 145, -1, 146, -1, 147, -1, 148, -1, 149,
2416 -1, 150, -1, 151, -1, 139, -1, 16, -1, 14,
2417 -1, 12, -1, 10, -1, 17, -1, 15, -1, 13,
2418 -1, 11, -1, 176, -1, 177, -1, 18, -1, 19,
2419 -1, 212, 152, -1, -1, 41, -1, 42, -1, 43,
2420 -1, 44, -1, 45, -1, 46, -1, 47, -1, -1,
2421 -1, 65, -1, 66, -1, 67, -1, 68, -1, 69,
2422 -1, 70, -1, 64, 4, -1, -1, 57, 4, -1,
2423 -1, 153, 57, 4, -1, 34, 24, -1, -1, 185,
2424 -1, -1, 153, 188, 187, -1, 185, -1, 57, 4,
2425 -1, 191, -1, 8, -1, 193, -1, 8, -1, 193,
2426 -1, 9, -1, 10, -1, 11, -1, 12, -1, 13,
2427 -1, 14, -1, 15, -1, 16, -1, 17, -1, 18,
2428 -1, 19, -1, 21, -1, 192, -1, 48, -1, 229,
2429 -1, 154, 4, -1, 190, 155, 195, 156, -1, 157,
2430 4, 158, 193, 159, -1, 160, 4, 158, 193, 161,
2431 -1, 162, 194, 163, -1, 162, 163, -1, 160, 162,
2432 194, 163, 161, -1, 160, 162, 163, 161, -1, 193,
2433 164, -1, 193, -1, 194, 153, 193, -1, 194, -1,
2434 194, 153, 37, -1, 37, -1, -1, 191, 157, 198,
2435 159, -1, 191, 157, 159, -1, 191, 165, 24, -1,
2436 191, 160, 198, 161, -1, 191, 162, 198, 163, -1,
2437 191, 162, 163, -1, 191, 160, 162, 198, 163, 161,
2438 -1, 191, 160, 162, 163, 161, -1, 191, 38, -1,
2439 191, 39, -1, 191, 229, -1, 191, 197, -1, 191,
2440 26, -1, 176, 168, -1, 177, 4, -1, 9, 27,
2441 -1, 9, 28, -1, 179, 7, -1, 175, 155, 196,
2442 36, 191, 156, -1, 110, 155, 196, 244, 156, -1,
2443 112, 155, 196, 153, 196, 153, 196, 156, -1, 169,
2444 155, 196, 153, 196, 156, -1, 170, 155, 196, 153,
2445 196, 156, -1, 171, 155, 196, 153, 196, 156, -1,
2446 103, 172, 155, 196, 153, 196, 156, -1, 104, 173,
2447 155, 196, 153, 196, 156, -1, 174, 155, 196, 153,
2448 196, 156, -1, 114, 155, 196, 153, 196, 156, -1,
2449 115, 155, 196, 153, 196, 153, 196, 156, -1, 116,
2450 155, 196, 153, 196, 153, 196, 156, -1, 198, 153,
2451 196, -1, 196, -1, 32, -1, 33, -1, 201, -1,
2452 201, 222, -1, 201, 224, -1, 201, 62, 61, 207,
2453 -1, 201, 25, -1, 202, -1, 202, 180, 20, 189,
2454 -1, 202, 224, -1, 202, 62, 61, 207, -1, -1,
2455 202, 180, 181, 199, 196, 203, 187, -1, -1, 202,
2456 180, 50, 199, 191, 204, 187, -1, -1, 202, 180,
2457 45, 199, 191, 205, 187, -1, -1, 202, 180, 47,
2458 199, 191, 206, 187, -1, 202, 51, 209, -1, 202,
2459 58, 152, 210, -1, -1, 24, -1, 56, -1, 55,
2460 -1, 53, 152, 208, -1, 54, 152, 4, -1, 52,
2461 152, 24, -1, 71, 152, 24, -1, 157, 211, 159,
2462 -1, 211, 153, 24, -1, 24, -1, -1, 22, -1,
2463 24, -1, 212, -1, -1, 191, 213, -1, 215, 153,
2464 214, -1, 214, -1, 215, -1, 215, 153, 37, -1,
2465 37, -1, -1, 182, 189, 212, 155, 216, 156, 186,
2466 183, -1, 29, -1, 162, -1, -1, 181, 220, 217,
2467 218, -1, 30, -1, 163, -1, 232, 221, -1, -1,
2468 45, -1, 47, -1, -1, -1, 31, 225, 223, 226,
2469 217, -1, -1, 63, -1, 3, -1, 4, -1, 7,
2470 -1, 27, -1, 28, -1, 38, -1, 39, -1, 26,
2471 -1, 160, 198, 161, -1, 197, -1, 61, 227, 24,
2472 153, 24, -1, 167, -1, 212, -1, 229, -1, 228,
2473 -1, 191, 230, -1, 232, 233, -1, 219, 233, -1,
2474 234, 180, 236, -1, 234, 238, -1, -1, 23, -1,
2475 77, -1, 78, -1, 72, 231, -1, 72, 8, -1,
2476 73, 21, 230, -1, 73, 9, 230, 153, 21, 230,
2477 153, 21, 230, -1, 74, 178, 230, 153, 21, 230,
2478 157, 237, 159, -1, 74, 178, 230, 153, 21, 230,
2479 157, 159, -1, 75, 182, 189, 230, 155, 241, 156,
2480 36, 21, 230, 235, 21, 230, -1, 235, -1, 76,
2481 -1, 237, 178, 228, 153, 21, 230, -1, 178, 228,
2482 153, 21, 230, -1, 180, 243, -1, 191, 157, 230,
2483 153, 230, 159, -1, 239, 153, 157, 230, 153, 230,
2484 159, -1, 231, -1, 240, 153, 231, -1, 240, -1,
2485 -1, 60, 59, -1, 59, -1, 169, 191, 230, 153,
2486 230, -1, 170, 191, 230, 153, 230, -1, 171, 191,
2487 230, 153, 230, -1, 103, 172, 191, 230, 153, 230,
2488 -1, 104, 173, 191, 230, 153, 230, -1, 49, 231,
2489 -1, 174, 231, 153, 231, -1, 175, 231, 36, 191,
2490 -1, 112, 231, 153, 231, 153, 231, -1, 113, 231,
2491 153, 191, -1, 117, 231, 153, 191, -1, 118, 231,
2492 153, 191, -1, 114, 231, 153, 231, -1, 115, 231,
2493 153, 231, 153, 231, -1, 116, 231, 153, 231, 153,
2494 231, -1, 111, 239, -1, 242, 182, 189, 230, 155,
2495 241, 156, -1, 246, -1, 153, 240, -1, -1, 35,
2496 -1, -1, 105, 191, 184, -1, 105, 191, 153, 15,
2497 230, 184, -1, 106, 191, 184, -1, 106, 191, 153,
2498 15, 230, 184, -1, 107, 231, -1, 245, 108, 191,
2499 230, -1, 245, 109, 231, 153, 191, 230, -1, 110,
2503 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
2504 static const unsigned short int yyrline[] =
2506 0, 1852, 1852, 1853, 1861, 1862, 1872, 1872, 1872, 1872,
2507 1872, 1872, 1872, 1872, 1872, 1872, 1872, 1876, 1876, 1876,
2508 1880, 1880, 1880, 1880, 1880, 1880, 1884, 1884, 1885, 1885,
2509 1886, 1886, 1887, 1887, 1888, 1888, 1892, 1892, 1893, 1893,
2510 1894, 1894, 1895, 1895, 1896, 1896, 1897, 1897, 1898, 1898,
2511 1899, 1900, 1903, 1903, 1903, 1903, 1907, 1907, 1907, 1907,
2512 1907, 1907, 1907, 1908, 1908, 1908, 1908, 1908, 1908, 1914,
2513 1914, 1914, 1914, 1918, 1918, 1918, 1918, 1922, 1922, 1926,
2514 1926, 1931, 1934, 1939, 1940, 1941, 1942, 1943, 1944, 1945,
2515 1946, 1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1967,
2516 1968, 1976, 1977, 1985, 1994, 1995, 2002, 2003, 2007, 2011,
2517 2027, 2028, 2035, 2036, 2043, 2051, 2051, 2051, 2051, 2051,
2518 2051, 2051, 2052, 2052, 2052, 2052, 2052, 2057, 2061, 2065,
2519 2070, 2079, 2097, 2103, 2116, 2127, 2131, 2144, 2148, 2162,
2520 2166, 2173, 2174, 2180, 2187, 2199, 2229, 2242, 2265, 2293,
2521 2315, 2326, 2348, 2359, 2368, 2373, 2432, 2439, 2447, 2454,
2522 2461, 2465, 2469, 2478, 2493, 2506, 2515, 2543, 2556, 2565,
2523 2571, 2577, 2588, 2594, 2600, 2611, 2612, 2621, 2622, 2634,
2524 2643, 2644, 2645, 2646, 2647, 2663, 2683, 2685, 2687, 2687,
2525 2694, 2694, 2702, 2702, 2710, 2710, 2719, 2721, 2723, 2728,
2526 2742, 2743, 2747, 2750, 2758, 2762, 2769, 2773, 2777, 2781,
2527 2789, 2789, 2793, 2794, 2798, 2806, 2811, 2819, 2820, 2827,
2528 2834, 2838, 3019, 3019, 3023, 3023, 3033, 3033, 3037, 3042,
2529 3043, 3044, 3048, 3049, 3048, 3061, 3062, 3067, 3068, 3069,
2530 3070, 3074, 3078, 3079, 3080, 3081, 3102, 3106, 3120, 3121,
2531 3126, 3126, 3134, 3144, 3147, 3156, 3167, 3172, 3181, 3192,
2532 3192, 3195, 3199, 3203, 3208, 3218, 3236, 3245, 3310, 3314,
2533 3321, 3333, 3348, 3378, 3388, 3398, 3402, 3409, 3410, 3414,
2534 3417, 3423, 3442, 3460, 3476, 3490, 3504, 3515, 3533, 3542,
2535 3551, 3558, 3579, 3603, 3609, 3615, 3621, 3637, 3721, 3729,
2536 3730, 3734, 3735, 3739, 3745, 3752, 3758, 3765, 3772, 3785,
2541 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
2542 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
2543 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
2544 static const char *const yytname[] =
2546 "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "SINTVAL",
2547 "UINTVAL", "FPVAL", "VOID", "BOOL", "SBYTE", "UBYTE", "SHORT", "USHORT",
2548 "INT", "UINT", "LONG", "ULONG", "FLOAT", "DOUBLE", "TYPE", "LABEL",
2549 "VAR_ID", "LABELSTR", "STRINGCONSTANT", "IMPLEMENTATION",
2550 "ZEROINITIALIZER", "TRUETOK", "FALSETOK", "BEGINTOK", "ENDTOK",
2551 "DECLARE", "GLOBAL", "CONSTANT", "SECTION", "VOLATILE", "TO",
2552 "DOTDOTDOT", "NULL_TOK", "UNDEF", "CONST", "INTERNAL", "LINKONCE",
2553 "WEAK", "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "OPAQUE",
2554 "NOT", "EXTERNAL", "TARGET", "TRIPLE", "ENDIAN", "POINTERSIZE", "LITTLE",
2555 "BIG", "ALIGN", "DEPLIBS", "CALL", "TAIL", "ASM_TOK", "MODULE",
2556 "SIDEEFFECT", "CC_TOK", "CCC_TOK", "CSRETCC_TOK", "FASTCC_TOK",
2557 "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT",
2558 "RET", "BR", "SWITCH", "INVOKE", "UNREACHABLE", "UNWIND", "EXCEPT",
2559 "ADD", "SUB", "MUL", "DIV", "UDIV", "SDIV", "FDIV", "REM", "UREM",
2560 "SREM", "FREM", "AND", "OR", "XOR", "SHL", "SHR", "ASHR", "LSHR",
2561 "SETLE", "SETGE", "SETLT", "SETGT", "SETEQ", "SETNE", "ICMP", "FCMP",
2562 "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE", "GETELEMENTPTR", "PHI_TOK",
2563 "SELECT", "VAARG", "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR",
2564 "VAARG_old", "VANEXT_old", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", "ULT",
2565 "UGT", "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD",
2566 "UNO", "UEQ", "UNE", "CAST", "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT",
2567 "FPTOUI", "FPTOSI", "UITOFP", "SITOFP", "PTRTOINT", "INTTOPTR",
2568 "BITCAST", "'='", "','", "'\\\\'", "'('", "')'", "'['", "'x'", "']'",
2569 "'<'", "'>'", "'{'", "'}'", "'*'", "'c'", "$accept", "INTVAL",
2570 "EINT64VAL", "ArithmeticOps", "LogicalOps", "SetCondOps", "IPredicates",
2571 "FPredicates", "ShiftOps", "CastOps", "SIntType", "UIntType", "IntType",
2572 "FPType", "OptAssign", "OptLinkage", "OptCallingConv", "OptAlign",
2573 "OptCAlign", "SectionString", "OptSection", "GlobalVarAttributes",
2574 "GlobalVarAttribute", "TypesV", "UpRTypesV", "Types", "PrimType",
2575 "UpRTypes", "TypeListI", "ArgTypeListI", "ConstVal", "ConstExpr",
2576 "ConstVector", "GlobalType", "Module", "FunctionList", "ConstPool", "@1",
2577 "@2", "@3", "@4", "AsmBlock", "BigOrLittle", "TargetDefinition",
2578 "LibrariesDefinition", "LibList", "Name", "OptName", "ArgVal",
2579 "ArgListH", "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader",
2580 "@5", "END", "Function", "FnDeclareLinkage", "FunctionProto", "@6", "@7",
2581 "OptSideEffect", "ConstValueRef", "SymbolicValueRef", "ValueRef",
2582 "ResolvedVal", "BasicBlockList", "BasicBlock", "InstructionList",
2583 "Unwind", "BBTerminatorInst", "JumpTable", "Inst", "PHIList",
2584 "ValueRefList", "ValueRefListE", "OptTailCall", "InstVal", "IndexList",
2585 "OptVolatile", "MemoryInst", 0
2590 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
2592 static const unsigned short int yytoknum[] =
2594 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
2595 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
2596 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
2597 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
2598 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
2599 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
2600 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
2601 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
2602 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
2603 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
2604 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
2605 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
2606 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
2607 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
2608 395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
2609 405, 406, 61, 44, 92, 40, 41, 91, 120, 93,
2610 60, 62, 123, 125, 42, 99
2614 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
2615 static const unsigned char yyr1[] =
2617 0, 166, 167, 167, 168, 168, 169, 169, 169, 169,
2618 169, 169, 169, 169, 169, 169, 169, 170, 170, 170,
2619 171, 171, 171, 171, 171, 171, 172, 172, 172, 172,
2620 172, 172, 172, 172, 172, 172, 173, 173, 173, 173,
2621 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
2622 173, 173, 174, 174, 174, 174, 175, 175, 175, 175,
2623 175, 175, 175, 175, 175, 175, 175, 175, 175, 176,
2624 176, 176, 176, 177, 177, 177, 177, 178, 178, 179,
2625 179, 180, 180, 181, 181, 181, 181, 181, 181, 181,
2626 181, 182, 182, 182, 182, 182, 182, 182, 182, 183,
2627 183, 184, 184, 185, 186, 186, 187, 187, 188, 188,
2628 189, 189, 190, 190, 191, 192, 192, 192, 192, 192,
2629 192, 192, 192, 192, 192, 192, 192, 193, 193, 193,
2630 193, 193, 193, 193, 193, 193, 193, 193, 193, 194,
2631 194, 195, 195, 195, 195, 196, 196, 196, 196, 196,
2632 196, 196, 196, 196, 196, 196, 196, 196, 196, 196,
2633 196, 196, 196, 197, 197, 197, 197, 197, 197, 197,
2634 197, 197, 197, 197, 197, 198, 198, 199, 199, 200,
2635 201, 201, 201, 201, 201, 202, 202, 202, 203, 202,
2636 204, 202, 205, 202, 206, 202, 202, 202, 202, 207,
2637 208, 208, 209, 209, 209, 209, 210, 211, 211, 211,
2638 212, 212, 213, 213, 214, 215, 215, 216, 216, 216,
2639 216, 217, 218, 218, 220, 219, 221, 221, 222, 223,
2640 223, 223, 225, 226, 224, 227, 227, 228, 228, 228,
2641 228, 228, 228, 228, 228, 228, 228, 228, 229, 229,
2642 230, 230, 231, 232, 232, 233, 234, 234, 234, 235,
2643 235, 236, 236, 236, 236, 236, 236, 236, 236, 236,
2644 237, 237, 238, 239, 239, 240, 240, 241, 241, 242,
2645 242, 243, 243, 243, 243, 243, 243, 243, 243, 243,
2646 243, 243, 243, 243, 243, 243, 243, 243, 243, 244,
2647 244, 245, 245, 246, 246, 246, 246, 246, 246, 246,
2651 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
2652 static const unsigned char yyr2[] =
2654 0, 2, 1, 1, 1, 1, 1, 1, 1, 1,
2655 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2656 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2657 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2658 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2659 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2660 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2661 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2662 1, 2, 0, 1, 1, 1, 1, 1, 1, 1,
2663 0, 0, 1, 1, 1, 1, 1, 1, 2, 0,
2664 2, 0, 3, 2, 0, 1, 0, 3, 1, 2,
2665 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2666 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2667 2, 4, 5, 5, 3, 2, 5, 4, 2, 1,
2668 3, 1, 3, 1, 0, 4, 3, 3, 4, 4,
2669 3, 6, 5, 2, 2, 2, 2, 2, 2, 2,
2670 2, 2, 2, 6, 5, 8, 6, 6, 6, 7,
2671 7, 6, 6, 8, 8, 3, 1, 1, 1, 1,
2672 2, 2, 4, 2, 1, 4, 2, 4, 0, 7,
2673 0, 7, 0, 7, 0, 7, 3, 4, 0, 1,
2674 1, 1, 3, 3, 3, 3, 3, 3, 1, 0,
2675 1, 1, 1, 0, 2, 3, 1, 1, 3, 1,
2676 0, 8, 1, 1, 0, 4, 1, 1, 2, 0,
2677 1, 1, 0, 0, 5, 0, 1, 1, 1, 1,
2678 1, 1, 1, 1, 1, 3, 1, 5, 1, 1,
2679 1, 1, 2, 2, 2, 3, 2, 0, 1, 1,
2680 1, 2, 2, 3, 9, 9, 8, 13, 1, 1,
2681 6, 5, 2, 6, 7, 1, 3, 1, 0, 2,
2682 1, 5, 5, 5, 6, 6, 2, 4, 4, 6,
2683 4, 4, 4, 4, 6, 6, 2, 7, 1, 2,
2684 0, 1, 0, 3, 6, 3, 6, 2, 4, 6,
2688 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
2689 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
2690 means the default is an error. */
2691 static const unsigned short int yydefact[] =
2693 198, 0, 90, 184, 1, 183, 232, 83, 84, 85,
2694 86, 87, 88, 89, 0, 224, 257, 180, 181, 257,
2695 210, 211, 0, 0, 0, 90, 0, 186, 229, 0,
2696 91, 258, 254, 82, 226, 227, 228, 253, 0, 0,
2697 0, 0, 196, 0, 0, 0, 0, 0, 0, 0,
2698 81, 230, 231, 233, 199, 182, 0, 92, 93, 94,
2699 95, 96, 97, 0, 0, 302, 256, 0, 0, 0,
2700 0, 209, 197, 187, 2, 3, 111, 115, 116, 117,
2701 118, 119, 120, 121, 122, 123, 124, 125, 126, 128,
2702 0, 0, 0, 0, 248, 185, 0, 110, 127, 114,
2703 249, 129, 177, 178, 0, 0, 0, 0, 91, 98,
2704 0, 222, 223, 225, 301, 0, 280, 0, 0, 0,
2705 0, 91, 269, 259, 260, 6, 7, 8, 9, 10,
2706 11, 12, 13, 14, 15, 16, 17, 18, 19, 52,
2707 53, 54, 55, 20, 21, 22, 23, 24, 25, 0,
2708 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2709 0, 0, 0, 68, 56, 57, 58, 59, 60, 61,
2710 62, 63, 64, 65, 66, 67, 0, 0, 0, 0,
2711 0, 268, 255, 91, 272, 0, 298, 204, 201, 200,
2712 202, 203, 205, 208, 0, 130, 0, 0, 0, 113,
2713 135, 139, 0, 144, 138, 192, 194, 190, 115, 116,
2714 117, 118, 119, 120, 121, 122, 123, 124, 125, 0,
2715 0, 0, 0, 188, 234, 0, 0, 286, 279, 262,
2716 261, 0, 0, 72, 76, 71, 75, 70, 74, 69,
2717 73, 77, 78, 0, 0, 26, 27, 28, 29, 30,
2718 31, 32, 33, 34, 35, 0, 50, 51, 46, 47,
2719 48, 49, 36, 37, 38, 39, 40, 41, 42, 43,
2720 44, 45, 0, 101, 101, 307, 0, 0, 296, 0,
2721 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2722 0, 0, 0, 0, 0, 206, 0, 0, 0, 0,
2723 0, 134, 143, 141, 0, 106, 106, 106, 160, 161,
2724 4, 5, 158, 159, 162, 157, 153, 154, 0, 0,
2725 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2726 0, 0, 0, 0, 156, 155, 106, 220, 237, 238,
2727 239, 244, 240, 241, 242, 243, 235, 0, 246, 251,
2728 250, 252, 0, 263, 0, 0, 0, 0, 0, 303,
2729 0, 305, 300, 0, 0, 0, 0, 0, 0, 0,
2730 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2731 207, 112, 112, 137, 0, 140, 0, 131, 0, 193,
2732 195, 191, 0, 0, 0, 0, 0, 0, 0, 146,
2733 176, 0, 0, 0, 150, 0, 147, 0, 0, 0,
2734 0, 0, 189, 219, 213, 216, 217, 0, 236, 0,
2735 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2736 310, 0, 0, 0, 290, 293, 0, 0, 291, 292,
2737 0, 0, 0, 287, 288, 0, 308, 0, 132, 133,
2738 136, 142, 0, 0, 108, 106, 0, 0, 300, 0,
2739 0, 0, 0, 0, 145, 135, 114, 0, 148, 149,
2740 0, 0, 0, 0, 0, 212, 214, 0, 104, 0,
2741 245, 0, 0, 278, 0, 0, 101, 102, 101, 275,
2742 299, 0, 0, 0, 0, 0, 281, 282, 283, 278,
2743 0, 103, 109, 107, 0, 0, 0, 0, 0, 0,
2744 0, 175, 152, 0, 0, 0, 0, 0, 0, 218,
2745 215, 105, 99, 0, 0, 0, 277, 0, 284, 285,
2746 0, 304, 306, 0, 0, 0, 289, 294, 295, 0,
2747 309, 0, 0, 164, 0, 0, 0, 0, 151, 0,
2748 0, 0, 0, 0, 0, 221, 247, 0, 0, 0,
2749 276, 273, 0, 297, 0, 0, 0, 172, 0, 0,
2750 166, 167, 168, 171, 163, 100, 0, 266, 0, 0,
2751 0, 274, 169, 170, 0, 0, 0, 264, 0, 265,
2752 0, 0, 165, 173, 174, 0, 0, 0, 0, 0,
2753 0, 271, 0, 0, 270, 267
2756 /* YYDEFGOTO[NTERM-NUM]. */
2757 static const short int yydefgoto[] =
2759 -1, 94, 312, 329, 330, 331, 255, 272, 332, 333,
2760 219, 220, 243, 221, 25, 15, 63, 555, 359, 454,
2761 522, 389, 455, 95, 96, 222, 98, 99, 202, 304,
2762 400, 348, 401, 104, 1, 2, 3, 336, 307, 305,
2763 306, 55, 190, 42, 72, 194, 100, 476, 415, 416,
2764 417, 64, 113, 16, 30, 36, 17, 53, 18, 28,
2765 108, 419, 349, 101, 351, 489, 19, 32, 33, 181,
2766 182, 579, 66, 278, 526, 527, 183, 184, 430, 185,
2770 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
2772 #define YYPACT_NINF -542
2773 static const short int yypact[] =
2775 -542, 13, 162, 567, -542, -542, -542, -542, -542, -542,
2776 -542, -542, -542, -542, 83, -542, 19, -542, -542, -14,
2777 -542, -542, 50, -87, 87, 233, 27, -542, 123, 141,
2778 175, -542, -542, 98, -542, -542, -542, -542, 33, 40,
2779 66, 68, -542, 14, 141, 1265, 156, 156, 156, 156,
2780 -542, -542, -542, -542, -542, -542, 221, -542, -542, -542,
2781 -542, -542, -542, 1265, -19, 1479, -542, 204, 135, 226,
2782 227, 235, -542, -542, -542, -542, 81, -542, -542, -542,
2783 -542, -542, -542, -542, -542, -542, -542, -542, -542, -542,
2784 256, 257, 4, 15, -542, -542, 108, -542, -542, 12,
2785 -542, -542, -542, -542, 1306, 1306, 1306, 1326, 175, -542,
2786 98, -542, -542, -542, -542, 1306, -542, 205, 1367, 116,
2787 479, 175, -542, -542, -542, -542, -542, -542, -542, -542,
2788 -542, -542, -542, -542, -542, -542, -542, -542, -542, -542,
2789 -542, -542, -542, -542, -542, -542, -542, -542, -542, 355,
2790 429, 1306, 1306, 1306, 1306, 1306, 1306, 1306, 1306, 1306,
2791 1306, 1306, 1306, -542, -542, -542, -542, -542, -542, -542,
2792 -542, -542, -542, -542, -542, -542, 1306, 1306, 1306, 1306,
2793 1306, -542, -542, 175, -542, 86, -542, -542, -542, -542,
2794 -542, -542, -542, -542, -13, -542, 110, 111, 75, -542,
2795 -542, 12, -81, 1046, -542, -542, -542, -542, 174, 208,
2796 266, 210, 267, 212, 268, 230, 277, 275, 278, 246,
2797 280, 279, 566, -542, -542, 136, 766, -542, -542, 81,
2798 -542, 766, 766, -542, -542, -542, -542, -542, -542, -542,
2799 -542, -542, -542, 766, 1265, -542, -542, -542, -542, -542,
2800 -542, -542, -542, -542, -542, 1306, -542, -542, -542, -542,
2801 -542, -542, -542, -542, -542, -542, -542, -542, -542, -542,
2802 -542, -542, 1306, 137, 145, -542, 766, 132, 146, 147,
2803 148, 149, 151, 152, 158, 160, 766, 766, 766, 161,
2804 281, 1265, 1306, 1306, 291, -542, 1306, 1306, 155, -27,
2805 1306, -542, -542, 165, 163, 176, 176, 176, -542, -542,
2806 -542, -542, -542, -542, -542, -542, -542, -542, 355, 429,
2807 172, 177, 178, 179, 182, 1087, 1387, 529, 311, 184,
2808 185, 186, 188, 189, -542, -542, 176, 1107, -542, -542,
2809 -542, -542, -542, -542, -542, -542, 282, 1326, -542, -542,
2810 -542, -542, 193, -542, 194, 766, 766, 766, 7, -542,
2811 20, -542, 195, 766, 192, 1306, 1306, 1306, 1306, 1306,
2812 1306, 1306, 200, 201, 206, 1306, 1306, 766, 766, 207,
2813 -542, -59, -149, -542, 196, 12, 1148, -542, 44, -542,
2814 -542, -542, 203, 211, 1326, 1326, 1326, 1326, 1326, -542,
2815 -542, -8, 741, -82, -542, 10, -542, 1326, 1326, 1326,
2816 1326, 1326, -542, -542, 98, -542, 214, 209, -542, 337,
2817 -34, 342, 348, 215, 218, 219, 766, 371, 766, 1306,
2818 -542, 223, 766, 224, -542, -542, 225, 234, -542, -542,
2819 766, 766, 766, -542, -542, 228, -542, 1306, -542, -542,
2820 -542, -542, 362, 375, -542, 176, 1326, 1326, 195, 236,
2821 237, 240, 243, 1326, -542, 238, -25, 11, -542, -542,
2822 244, 245, 247, 250, 352, -542, -542, 1205, 370, 252,
2823 -542, 766, 766, 1306, 766, 766, 258, -542, 258, -542,
2824 259, 766, 264, 1306, 1306, 1306, -542, -542, -542, 1306,
2825 766, -542, -542, -542, 270, 271, 263, 1326, 1326, 1326,
2826 1326, -542, -542, 260, 1326, 1326, 1326, 1326, 1306, -542,
2827 -542, -542, 368, 402, 274, 276, 259, 287, -542, -542,
2828 374, -542, -542, 1306, 285, 766, -542, -542, -542, 290,
2829 -542, 1326, 1326, -542, 283, 295, 284, 294, -542, 296,
2830 297, 299, 302, 303, 430, -542, -542, 414, 41, 425,
2831 -542, -542, 305, -542, 306, 310, 1326, -542, 1326, 1326,
2832 -542, -542, -542, -542, -542, -542, 766, -542, 893, 144,
2833 448, -542, -542, -542, 314, 315, 316, -542, 331, -542,
2834 893, 766, -542, -542, -542, 464, 334, 180, 766, 481,
2835 482, -542, 766, 766, -542, -542
2838 /* YYPGOTO[NTERM-NUM]. */
2839 static const short int yypgoto[] =
2841 -542, -542, -542, 435, 439, 441, 191, 197, 442, 445,
2842 -119, -116, -541, -542, 478, 489, -107, -542, -267, 37,
2843 -542, -238, -542, -60, -542, -45, -542, -74, -51, -542,
2844 -101, 300, -252, 134, -542, -542, -542, -542, -542, -542,
2845 -542, 473, -542, -542, -542, -542, 8, -542, 46, -542,
2846 -542, 410, -542, -542, -542, -542, -542, -542, 518, -542,
2847 -542, -542, -528, 142, -90, -113, -542, 505, -542, -72,
2848 -542, -542, -542, -542, 97, 28, -542, -542, 70, -542,
2852 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
2853 positive, shift that token. If negative, reduce the rule which
2854 number is the opposite. If zero, do what YYDEFACT says.
2855 If YYTABLE_NINF, syntax error. */
2856 #define YYTABLE_NINF -180
2857 static const short int yytable[] =
2859 97, 241, 227, 110, 242, 230, 223, 361, 197, 31,
2860 111, 26, 449, 4, 244, 204, 34, 578, 97, 201,
2861 74, 75, 426, 199, 77, 78, 79, 80, 81, 82,
2862 83, 84, 85, 86, 87, 428, 88, 20, 590, 21,
2863 275, 26, 31, 279, 280, 281, 282, 283, 284, 285,
2864 588, 233, 234, 235, 236, 237, 238, 239, 240, 205,
2865 206, 207, 596, 89, 427, 43, 289, 290, 390, 391,
2866 226, 463, 300, 226, 403, 405, 291, 427, 452, 468,
2867 74, 75, 301, 199, 77, 78, 79, 80, 81, 82,
2868 83, 84, 85, 86, 87, 420, 88, 20, 412, 21,
2869 448, 453, 38, 39, 40, 204, 273, 274, 226, 276,
2870 277, 226, 226, 226, 226, 226, 226, 226, 225, 463,
2871 20, 41, 21, 89, 201, 231, 300, 480, -139, 201,
2872 -112, 286, 287, 288, 226, 226, 384, 232, -139, 204,
2873 294, 352, 353, 112, 29, 463, 295, 299, 44, 35,
2874 467, 464, 303, 354, 233, 234, 235, 236, 237, 238,
2875 239, 240, -179, 463, 463, 54, 198, -112, 51, 90,
2876 52, 71, 91, 469, 513, 92, 204, 93, 200, 50,
2877 379, 105, 106, 107, 355, 67, 362, 5, 102, 103,
2878 188, 189, 68, 6, 292, 293, 372, 373, 374, 97,
2879 577, 308, 309, 7, 8, 9, 10, 11, 12, 13,
2880 356, -72, -72, -71, -71, -70, -70, 503, 69, 531,
2881 70, 532, 381, 382, 14, 109, 385, 357, 187, 90,
2882 191, 377, 91, -69, -69, 92, -113, 93, 298, 56,
2883 57, 58, 59, 60, 61, 62, 97, 378, 226, 310,
2884 311, 192, 433, 45, 435, 436, 437, 123, 124, 193,
2885 195, 196, 443, 203, 228, 423, 424, 425, 296, 297,
2886 -76, -75, -74, 431, 7, 8, 9, 10, 46, 12,
2887 47, -73, -79, 48, 313, -80, 314, 445, 446, 363,
2888 358, 337, 414, 458, 459, 460, 461, 462, 360, 364,
2889 365, 366, 367, 589, 368, 369, 470, 471, 472, 473,
2890 474, 370, 385, 371, 375, 380, 383, 376, 386, 387,
2891 226, 434, 226, 226, 226, 438, 439, 394, 466, 388,
2892 226, 444, 395, 396, 397, 406, 486, 398, 488, 407,
2893 408, 409, 492, 410, 411, 418, 421, 422, 429, 432,
2894 496, 497, 498, 440, 441, 504, 505, 450, 456, 442,
2895 447, 479, 511, 481, 335, 478, 457, 477, 350, 482,
2896 483, 484, 485, 350, 350, 487, 491, 493, 494, 502,
2897 536, 537, 538, 499, 226, 350, 501, 495, 518, 507,
2898 508, 524, 525, 509, 528, 529, 510, 514, 515, 512,
2899 516, 534, 500, 517, 452, 523, 544, 545, 546, 547,
2900 540, 530, 533, 549, 550, 551, 552, 535, 350, 543,
2901 560, 548, 475, 541, 542, 554, 556, 557, 350, 350,
2902 350, 427, 414, 558, 575, 576, 566, 568, 226, 241,
2903 564, 565, 242, 559, 561, 562, 563, 569, 226, 226,
2904 226, 567, 570, 571, 226, 572, 256, 257, 573, 574,
2905 241, 580, 582, 242, 581, 584, 583, 585, 586, 591,
2906 592, 593, 594, 553, 245, 246, 247, 248, 249, 250,
2907 251, 252, 253, 254, 595, 598, 587, 599, 226, 233,
2908 234, 235, 236, 237, 238, 239, 240, 350, 350, 350,
2909 176, 597, 602, 603, 177, 350, 178, 179, 601, 392,
2910 180, 65, 604, 605, 49, 521, 393, 73, 224, 350,
2911 350, 27, 334, 520, 37, 600, 490, 539, 506, 0,
2912 0, 0, 0, 0, 74, 75, 0, 199, 208, 209,
2913 210, 211, 212, 213, 214, 215, 216, 217, 218, 0,
2914 88, 20, 0, 21, 258, 259, 260, 261, 262, 263,
2915 264, 265, 266, 267, 268, 269, 270, 271, 350, 0,
2916 350, 74, 75, 0, 350, 0, 0, 89, 0, 0,
2917 0, 0, 350, 350, 350, 0, 0, -82, 20, 20,
2918 21, 21, 315, 0, 0, 0, 0, 0, 6, -82,
2919 -82, 0, 0, 0, 316, 317, 0, 0, -82, -82,
2920 -82, -82, -82, -82, -82, 0, 0, -82, 22, 0,
2921 0, 0, 0, 350, 350, 23, 350, 350, 0, 24,
2922 0, 0, 0, 350, 0, 0, 0, 0, 0, 0,
2923 0, 0, 350, 0, 0, 125, 126, 127, 128, 129,
2924 130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
2925 140, 141, 142, 143, 144, 145, 146, 147, 148, 318,
2926 319, 0, 0, 0, 0, 0, 320, 350, 321, 0,
2927 322, 323, 324, 90, 0, 0, 91, 0, 0, 92,
2928 0, 93, 404, 0, 0, 0, 0, 0, 0, 0,
2929 0, 0, 0, 0, 0, 163, 164, 165, 166, 167,
2930 168, 169, 170, 171, 172, 173, 174, 175, 350, 0,
2931 0, 0, 0, 325, 0, 0, 326, 0, 327, 0,
2932 0, 328, 0, 350, 0, 0, 0, 0, 0, 0,
2933 350, 0, 0, 0, 350, 350, 74, 75, 0, 199,
2934 208, 209, 210, 211, 212, 213, 214, 215, 216, 217,
2935 218, 0, 88, 20, 0, 21, 0, 0, 0, 338,
2936 339, 74, 75, 340, 0, 0, 0, 0, 0, 0,
2937 0, 0, 0, 0, 0, 0, 0, 0, 20, 89,
2938 21, 0, 341, 342, 343, 0, 0, 0, 0, 0,
2939 0, 0, 0, 0, 344, 345, 0, 0, 0, 0,
2940 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2941 0, 0, 0, 0, 0, 0, 0, 346, 0, 0,
2942 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2943 0, 0, 0, 0, 0, 125, 126, 127, 128, 129,
2944 130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
2945 140, 141, 142, 143, 144, 145, 146, 147, 148, 318,
2946 319, 0, 0, 0, 0, 0, 320, 0, 321, 0,
2947 322, 323, 324, 0, 0, 0, 0, 0, 0, 0,
2948 0, 0, 0, 0, 0, 90, 338, 339, 91, 0,
2949 340, 92, 0, 93, 465, 163, 164, 165, 166, 167,
2950 168, 169, 170, 171, 172, 173, 174, 175, 0, 341,
2951 342, 343, 0, 0, 0, 0, 347, 0, 0, 0,
2952 0, 344, 345, 0, 0, 0, 0, 0, 0, 0,
2953 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2954 0, 0, 0, 0, 346, 0, 0, 0, 0, 0,
2955 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2956 0, 0, 125, 126, 127, 128, 129, 130, 131, 132,
2957 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
2958 143, 144, 145, 146, 147, 148, 318, 319, 0, 0,
2959 0, 0, 0, 320, 0, 321, 0, 322, 323, 324,
2960 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2961 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2962 0, 0, 163, 164, 165, 166, 167, 168, 169, 170,
2963 171, 172, 173, 174, 175, 0, 0, 0, 0, 0,
2964 0, 74, 75, 347, 199, 77, 78, 79, 80, 81,
2965 82, 83, 84, 85, 86, 87, 0, 88, 20, 0,
2966 21, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2967 0, 0, 0, 302, 0, 0, 0, 0, 0, 0,
2968 0, 0, 74, 75, 89, 199, 208, 209, 210, 211,
2969 212, 213, 214, 215, 216, 217, 218, 0, 88, 20,
2970 0, 21, 74, 75, 0, 199, 77, 78, 79, 80,
2971 81, 82, 83, 84, 85, 86, 87, 0, 88, 20,
2972 0, 21, 0, 0, 0, 89, 0, 0, 0, 0,
2973 0, 0, 0, 0, 413, 0, 0, 0, 0, 0,
2974 0, 0, 0, 74, 75, 89, 199, 77, 78, 79,
2975 80, 81, 82, 83, 84, 85, 86, 87, 0, 88,
2976 20, 0, 21, 0, 0, 0, 0, 0, 0, 0,
2977 0, 0, 0, 0, 0, 451, 0, 0, 0, 0,
2978 0, 0, 0, 0, 0, 0, 89, 0, 0, 0,
2979 90, 0, 0, 91, 0, 0, 92, 0, 93, 0,
2980 74, 75, 0, 199, 77, 78, 79, 80, 81, 82,
2981 83, 84, 85, 86, 87, 0, 88, 20, 0, 21,
2982 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2983 0, 90, 519, 0, 91, 0, 399, 92, 0, 93,
2984 0, 0, 0, 89, 0, 0, 0, 0, 0, 0,
2985 0, 90, 0, 0, 91, 0, 0, 92, 0, 93,
2986 74, 75, 0, 76, 77, 78, 79, 80, 81, 82,
2987 83, 84, 85, 86, 87, 0, 88, 20, 0, 21,
2988 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2989 0, 0, 90, 0, 0, 91, 0, 0, 92, 0,
2990 93, 74, 75, 89, 199, 77, 78, 79, 80, 81,
2991 82, 83, 84, 85, 86, 87, 0, 88, 20, 0,
2992 21, 74, 75, 0, 199, 208, 209, 210, 211, 212,
2993 213, 214, 215, 216, 217, 218, 0, 88, 20, 0,
2994 21, 0, 0, 0, 89, 0, 0, 0, 0, 90,
2995 0, 0, 91, 0, 0, 92, 0, 93, 0, 0,
2996 0, 0, 74, 75, 89, 229, 77, 78, 79, 80,
2997 81, 82, 83, 84, 85, 86, 87, 0, 88, 20,
2998 0, 21, 74, 75, 0, 199, 208, 209, 210, 211,
2999 212, 213, 214, 215, 216, 217, 218, 0, 88, 20,
3000 0, 21, 0, 0, 0, 89, 0, 0, 0, 90,
3001 0, 0, 91, 0, 0, 92, 0, 93, 0, 0,
3002 0, 0, 0, 0, 0, 89, 0, 0, 0, 0,
3003 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3004 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3005 90, 0, 0, 91, 0, 0, 92, 0, 93, 0,
3006 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3007 90, 0, 0, 91, 0, 0, 92, 0, 93, 0,
3008 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3009 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3010 0, 0, 0, 0, 114, 0, 0, 0, 0, 0,
3011 0, 90, 0, 0, 91, 0, 0, 92, 115, 93,
3012 0, 0, 0, 0, 0, 0, 0, 0, 116, 117,
3013 0, 90, 0, 0, 91, 0, 0, 92, 0, 402,
3014 0, 118, 119, 120, 121, 122, 123, 124, 125, 126,
3015 127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
3016 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
3017 147, 148, 149, 150, 151, 152, 153, 0, 0, 154,
3018 155, 156, 157, 158, 159, 160, 161, 162, 0, 0,
3019 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3020 0, 0, 0, 0, 0, 0, 0, 0, 163, 164,
3021 165, 166, 167, 168, 169, 170, 171, 172, 173, 174,
3025 static const short int yycheck[] =
3027 45, 120, 115, 63, 120, 118, 107, 274, 4, 23,
3028 29, 3, 161, 0, 121, 164, 30, 558, 63, 93,
3029 5, 6, 15, 8, 9, 10, 11, 12, 13, 14,
3030 15, 16, 17, 18, 19, 15, 21, 22, 579, 24,
3031 153, 33, 23, 156, 157, 158, 159, 160, 161, 162,
3032 578, 10, 11, 12, 13, 14, 15, 16, 17, 104,
3033 105, 106, 590, 48, 57, 152, 179, 180, 306, 307,
3034 115, 153, 153, 118, 326, 327, 183, 57, 34, 161,
3035 5, 6, 163, 8, 9, 10, 11, 12, 13, 14,
3036 15, 16, 17, 18, 19, 347, 21, 22, 336, 24,
3037 159, 57, 52, 53, 54, 164, 151, 152, 153, 154,
3038 155, 156, 157, 158, 159, 160, 161, 162, 110, 153,
3039 22, 71, 24, 48, 198, 9, 153, 161, 153, 203,
3040 155, 176, 177, 178, 179, 180, 163, 21, 163, 164,
3041 153, 231, 232, 162, 61, 153, 159, 198, 61, 163,
3042 402, 159, 203, 243, 10, 11, 12, 13, 14, 15,
3043 16, 17, 0, 153, 153, 24, 162, 155, 45, 154,
3044 47, 157, 157, 163, 163, 160, 164, 162, 163, 152,
3045 293, 47, 48, 49, 244, 152, 276, 25, 32, 33,
3046 55, 56, 152, 31, 108, 109, 286, 287, 288, 244,
3047 159, 27, 28, 41, 42, 43, 44, 45, 46, 47,
3048 255, 3, 4, 3, 4, 3, 4, 455, 152, 486,
3049 152, 488, 296, 297, 62, 4, 300, 272, 24, 154,
3050 4, 291, 157, 3, 4, 160, 155, 162, 163, 64,
3051 65, 66, 67, 68, 69, 70, 291, 292, 293, 3,
3052 4, 24, 365, 20, 367, 368, 369, 77, 78, 24,
3053 4, 4, 375, 155, 59, 355, 356, 357, 158, 158,
3054 4, 4, 4, 363, 41, 42, 43, 44, 45, 46,
3055 47, 4, 7, 50, 4, 7, 7, 377, 378, 157,
3056 153, 155, 337, 394, 395, 396, 397, 398, 153, 153,
3057 153, 153, 153, 159, 153, 153, 407, 408, 409, 410,
3058 411, 153, 386, 153, 153, 24, 161, 36, 153, 156,
3059 365, 366, 367, 368, 369, 370, 371, 155, 402, 153,
3060 375, 376, 155, 155, 155, 24, 426, 155, 428, 155,
3061 155, 155, 432, 155, 155, 63, 153, 153, 153, 157,
3062 440, 441, 442, 153, 153, 456, 457, 161, 155, 153,
3063 153, 24, 463, 21, 222, 156, 155, 153, 226, 21,
3064 155, 153, 153, 231, 232, 4, 153, 153, 153, 4,
3065 493, 494, 495, 155, 429, 243, 24, 153, 36, 153,
3066 153, 481, 482, 153, 484, 485, 153, 153, 153, 161,
3067 153, 491, 447, 153, 34, 153, 507, 508, 509, 510,
3068 500, 153, 153, 514, 515, 516, 517, 153, 276, 156,
3069 533, 161, 414, 153, 153, 57, 24, 153, 286, 287,
3070 288, 57, 477, 157, 4, 21, 153, 153, 483, 558,
3071 541, 542, 558, 156, 159, 535, 156, 153, 493, 494,
3072 495, 156, 156, 156, 499, 156, 27, 28, 156, 156,
3073 579, 36, 156, 579, 159, 566, 156, 568, 569, 21,
3074 156, 156, 156, 518, 119, 120, 121, 122, 123, 124,
3075 125, 126, 127, 128, 153, 21, 576, 153, 533, 10,
3076 11, 12, 13, 14, 15, 16, 17, 355, 356, 357,
3077 65, 591, 21, 21, 65, 363, 65, 65, 598, 318,
3078 65, 33, 602, 603, 25, 478, 319, 44, 108, 377,
3079 378, 3, 222, 477, 19, 597, 429, 499, 458, -1,
3080 -1, -1, -1, -1, 5, 6, -1, 8, 9, 10,
3081 11, 12, 13, 14, 15, 16, 17, 18, 19, -1,
3082 21, 22, -1, 24, 125, 126, 127, 128, 129, 130,
3083 131, 132, 133, 134, 135, 136, 137, 138, 426, -1,
3084 428, 5, 6, -1, 432, -1, -1, 48, -1, -1,
3085 -1, -1, 440, 441, 442, -1, -1, 20, 22, 22,
3086 24, 24, 26, -1, -1, -1, -1, -1, 31, 32,
3087 33, -1, -1, -1, 38, 39, -1, -1, 41, 42,
3088 43, 44, 45, 46, 47, -1, -1, 50, 51, -1,
3089 -1, -1, -1, 481, 482, 58, 484, 485, -1, 62,
3090 -1, -1, -1, 491, -1, -1, -1, -1, -1, -1,
3091 -1, -1, 500, -1, -1, 79, 80, 81, 82, 83,
3092 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
3093 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
3094 104, -1, -1, -1, -1, -1, 110, 535, 112, -1,
3095 114, 115, 116, 154, -1, -1, 157, -1, -1, 160,
3096 -1, 162, 163, -1, -1, -1, -1, -1, -1, -1,
3097 -1, -1, -1, -1, -1, 139, 140, 141, 142, 143,
3098 144, 145, 146, 147, 148, 149, 150, 151, 576, -1,
3099 -1, -1, -1, 157, -1, -1, 160, -1, 162, -1,
3100 -1, 165, -1, 591, -1, -1, -1, -1, -1, -1,
3101 598, -1, -1, -1, 602, 603, 5, 6, -1, 8,
3102 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
3103 19, -1, 21, 22, -1, 24, -1, -1, -1, 3,
3104 4, 5, 6, 7, -1, -1, -1, -1, -1, -1,
3105 -1, -1, -1, -1, -1, -1, -1, -1, 22, 48,
3106 24, -1, 26, 27, 28, -1, -1, -1, -1, -1,
3107 -1, -1, -1, -1, 38, 39, -1, -1, -1, -1,
3108 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3109 -1, -1, -1, -1, -1, -1, -1, 61, -1, -1,
3110 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3111 -1, -1, -1, -1, -1, 79, 80, 81, 82, 83,
3112 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
3113 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
3114 104, -1, -1, -1, -1, -1, 110, -1, 112, -1,
3115 114, 115, 116, -1, -1, -1, -1, -1, -1, -1,
3116 -1, -1, -1, -1, -1, 154, 3, 4, 157, -1,
3117 7, 160, -1, 162, 163, 139, 140, 141, 142, 143,
3118 144, 145, 146, 147, 148, 149, 150, 151, -1, 26,
3119 27, 28, -1, -1, -1, -1, 160, -1, -1, -1,
3120 -1, 38, 39, -1, -1, -1, -1, -1, -1, -1,
3121 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3122 -1, -1, -1, -1, 61, -1, -1, -1, -1, -1,
3123 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3124 -1, -1, 79, 80, 81, 82, 83, 84, 85, 86,
3125 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
3126 97, 98, 99, 100, 101, 102, 103, 104, -1, -1,
3127 -1, -1, -1, 110, -1, 112, -1, 114, 115, 116,
3128 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3129 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3130 -1, -1, 139, 140, 141, 142, 143, 144, 145, 146,
3131 147, 148, 149, 150, 151, -1, -1, -1, -1, -1,
3132 -1, 5, 6, 160, 8, 9, 10, 11, 12, 13,
3133 14, 15, 16, 17, 18, 19, -1, 21, 22, -1,
3134 24, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3135 -1, -1, -1, 37, -1, -1, -1, -1, -1, -1,
3136 -1, -1, 5, 6, 48, 8, 9, 10, 11, 12,
3137 13, 14, 15, 16, 17, 18, 19, -1, 21, 22,
3138 -1, 24, 5, 6, -1, 8, 9, 10, 11, 12,
3139 13, 14, 15, 16, 17, 18, 19, -1, 21, 22,
3140 -1, 24, -1, -1, -1, 48, -1, -1, -1, -1,
3141 -1, -1, -1, -1, 37, -1, -1, -1, -1, -1,
3142 -1, -1, -1, 5, 6, 48, 8, 9, 10, 11,
3143 12, 13, 14, 15, 16, 17, 18, 19, -1, 21,
3144 22, -1, 24, -1, -1, -1, -1, -1, -1, -1,
3145 -1, -1, -1, -1, -1, 37, -1, -1, -1, -1,
3146 -1, -1, -1, -1, -1, -1, 48, -1, -1, -1,
3147 154, -1, -1, 157, -1, -1, 160, -1, 162, -1,
3148 5, 6, -1, 8, 9, 10, 11, 12, 13, 14,
3149 15, 16, 17, 18, 19, -1, 21, 22, -1, 24,
3150 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3151 -1, 154, 37, -1, 157, -1, 159, 160, -1, 162,
3152 -1, -1, -1, 48, -1, -1, -1, -1, -1, -1,
3153 -1, 154, -1, -1, 157, -1, -1, 160, -1, 162,
3154 5, 6, -1, 8, 9, 10, 11, 12, 13, 14,
3155 15, 16, 17, 18, 19, -1, 21, 22, -1, 24,
3156 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3157 -1, -1, 154, -1, -1, 157, -1, -1, 160, -1,
3158 162, 5, 6, 48, 8, 9, 10, 11, 12, 13,
3159 14, 15, 16, 17, 18, 19, -1, 21, 22, -1,
3160 24, 5, 6, -1, 8, 9, 10, 11, 12, 13,
3161 14, 15, 16, 17, 18, 19, -1, 21, 22, -1,
3162 24, -1, -1, -1, 48, -1, -1, -1, -1, 154,
3163 -1, -1, 157, -1, -1, 160, -1, 162, -1, -1,
3164 -1, -1, 5, 6, 48, 8, 9, 10, 11, 12,
3165 13, 14, 15, 16, 17, 18, 19, -1, 21, 22,
3166 -1, 24, 5, 6, -1, 8, 9, 10, 11, 12,
3167 13, 14, 15, 16, 17, 18, 19, -1, 21, 22,
3168 -1, 24, -1, -1, -1, 48, -1, -1, -1, 154,
3169 -1, -1, 157, -1, -1, 160, -1, 162, -1, -1,
3170 -1, -1, -1, -1, -1, 48, -1, -1, -1, -1,
3171 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3172 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3173 154, -1, -1, 157, -1, -1, 160, -1, 162, -1,
3174 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3175 154, -1, -1, 157, -1, -1, 160, -1, 162, -1,
3176 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3177 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3178 -1, -1, -1, -1, 35, -1, -1, -1, -1, -1,
3179 -1, 154, -1, -1, 157, -1, -1, 160, 49, 162,
3180 -1, -1, -1, -1, -1, -1, -1, -1, 59, 60,
3181 -1, 154, -1, -1, 157, -1, -1, 160, -1, 162,
3182 -1, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3183 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
3184 91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
3185 101, 102, 103, 104, 105, 106, 107, -1, -1, 110,
3186 111, 112, 113, 114, 115, 116, 117, 118, -1, -1,
3187 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3188 -1, -1, -1, -1, -1, -1, -1, -1, 139, 140,
3189 141, 142, 143, 144, 145, 146, 147, 148, 149, 150,
3193 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
3194 symbol of state STATE-NUM. */
3195 static const unsigned char yystos[] =
3197 0, 200, 201, 202, 0, 25, 31, 41, 42, 43,
3198 44, 45, 46, 47, 62, 181, 219, 222, 224, 232,
3199 22, 24, 51, 58, 62, 180, 212, 224, 225, 61,
3200 220, 23, 233, 234, 30, 163, 221, 233, 52, 53,
3201 54, 71, 209, 152, 61, 20, 45, 47, 50, 181,
3202 152, 45, 47, 223, 24, 207, 64, 65, 66, 67,
3203 68, 69, 70, 182, 217, 180, 238, 152, 152, 152,
3204 152, 157, 210, 207, 5, 6, 8, 9, 10, 11,
3205 12, 13, 14, 15, 16, 17, 18, 19, 21, 48,
3206 154, 157, 160, 162, 167, 189, 190, 191, 192, 193,
3207 212, 229, 32, 33, 199, 199, 199, 199, 226, 4,
3208 189, 29, 162, 218, 35, 49, 59, 60, 72, 73,
3209 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
3210 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
3211 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
3212 104, 105, 106, 107, 110, 111, 112, 113, 114, 115,
3213 116, 117, 118, 139, 140, 141, 142, 143, 144, 145,
3214 146, 147, 148, 149, 150, 151, 169, 170, 171, 174,
3215 175, 235, 236, 242, 243, 245, 246, 24, 55, 56,
3216 208, 4, 24, 24, 211, 4, 4, 4, 162, 8,
3217 163, 193, 194, 155, 164, 191, 191, 191, 9, 10,
3218 11, 12, 13, 14, 15, 16, 17, 18, 19, 176,
3219 177, 179, 191, 196, 217, 212, 191, 231, 59, 8,
3220 231, 9, 21, 10, 11, 12, 13, 14, 15, 16,
3221 17, 176, 177, 178, 182, 119, 120, 121, 122, 123,
3222 124, 125, 126, 127, 128, 172, 27, 28, 125, 126,
3223 127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
3224 137, 138, 173, 191, 191, 231, 191, 191, 239, 231,
3225 231, 231, 231, 231, 231, 231, 191, 191, 191, 231,
3226 231, 182, 108, 109, 153, 159, 158, 158, 163, 194,
3227 153, 163, 37, 194, 195, 205, 206, 204, 27, 28,
3228 3, 4, 168, 4, 7, 26, 38, 39, 103, 104,
3229 110, 112, 114, 115, 116, 157, 160, 162, 165, 169,
3230 170, 171, 174, 175, 197, 229, 203, 155, 3, 4,
3231 7, 26, 27, 28, 38, 39, 61, 160, 197, 228,
3232 229, 230, 230, 230, 230, 189, 191, 191, 153, 184,
3233 153, 184, 230, 157, 153, 153, 153, 153, 153, 153,
3234 153, 153, 230, 230, 230, 153, 36, 189, 191, 231,
3235 24, 193, 193, 161, 163, 193, 153, 156, 153, 187,
3236 187, 187, 172, 173, 155, 155, 155, 155, 155, 159,
3237 196, 198, 162, 198, 163, 198, 24, 155, 155, 155,
3238 155, 155, 187, 37, 191, 214, 215, 216, 63, 227,
3239 198, 153, 153, 230, 230, 230, 15, 57, 15, 153,
3240 244, 230, 157, 231, 191, 231, 231, 231, 191, 191,
3241 153, 153, 153, 231, 191, 230, 230, 153, 159, 161,
3242 161, 37, 34, 57, 185, 188, 155, 155, 196, 196,
3243 196, 196, 196, 153, 159, 163, 193, 198, 161, 163,
3244 196, 196, 196, 196, 196, 212, 213, 153, 156, 24,
3245 161, 21, 21, 155, 153, 153, 230, 4, 230, 231,
3246 240, 153, 230, 153, 153, 153, 230, 230, 230, 155,
3247 191, 24, 4, 187, 196, 196, 244, 153, 153, 153,
3248 153, 196, 161, 163, 153, 153, 153, 153, 36, 37,
3249 214, 185, 186, 153, 230, 230, 240, 241, 230, 230,
3250 153, 184, 184, 153, 230, 153, 231, 231, 231, 241,
3251 230, 153, 153, 156, 196, 196, 196, 196, 161, 196,
3252 196, 196, 196, 191, 57, 183, 24, 153, 157, 156,
3253 231, 159, 230, 156, 196, 196, 153, 156, 153, 153,
3254 156, 156, 156, 156, 156, 4, 21, 159, 178, 237,
3255 36, 159, 156, 156, 196, 196, 196, 230, 228, 159,
3256 178, 21, 156, 156, 156, 153, 228, 230, 21, 153,
3257 235, 230, 21, 21, 230, 230
3260 #define yyerrok (yyerrstatus = 0)
3261 #define yyclearin (yychar = YYEMPTY)
3262 #define YYEMPTY (-2)
3265 #define YYACCEPT goto yyacceptlab
3266 #define YYABORT goto yyabortlab
3267 #define YYERROR goto yyerrorlab
3270 /* Like YYERROR except do call yyerror. This remains here temporarily
3271 to ease the transition to the new meaning of YYERROR, for GCC.
3272 Once GCC version 2 has supplanted version 1, this can go. */
3274 #define YYFAIL goto yyerrlab
3276 #define YYRECOVERING() (!!yyerrstatus)
3278 #define YYBACKUP(Token, Value) \
3280 if (yychar == YYEMPTY && yylen == 1) \
3284 yytoken = YYTRANSLATE (yychar); \
3290 yyerror (YY_("syntax error: cannot back up")); \
3297 #define YYERRCODE 256
3300 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
3301 If N is 0, then set CURRENT to the empty location which ends
3302 the previous symbol: RHS[0] (always defined). */
3304 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
3305 #ifndef YYLLOC_DEFAULT
3306 # define YYLLOC_DEFAULT(Current, Rhs, N) \
3310 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
3311 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
3312 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
3313 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
3317 (Current).first_line = (Current).last_line = \
3318 YYRHSLOC (Rhs, 0).last_line; \
3319 (Current).first_column = (Current).last_column = \
3320 YYRHSLOC (Rhs, 0).last_column; \
3326 /* YY_LOCATION_PRINT -- Print the location on the stream.
3327 This macro was not mandated originally: define only if we know
3328 we won't break user code: when these are the locations we know. */
3330 #ifndef YY_LOCATION_PRINT
3331 # if YYLTYPE_IS_TRIVIAL
3332 # define YY_LOCATION_PRINT(File, Loc) \
3333 fprintf (File, "%d.%d-%d.%d", \
3334 (Loc).first_line, (Loc).first_column, \
3335 (Loc).last_line, (Loc).last_column)
3337 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
3342 /* YYLEX -- calling `yylex' with the right arguments. */
3345 # define YYLEX yylex (YYLEX_PARAM)
3347 # define YYLEX yylex ()
3350 /* Enable debugging if requested. */
3354 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
3355 # define YYFPRINTF fprintf
3358 # define YYDPRINTF(Args) \
3364 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
3368 YYFPRINTF (stderr, "%s ", Title); \
3369 yysymprint (stderr, \
3371 YYFPRINTF (stderr, "\n"); \
3375 /*------------------------------------------------------------------.
3376 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
3378 `------------------------------------------------------------------*/
3380 #if defined (__STDC__) || defined (__cplusplus)
3382 yy_stack_print (short int *bottom, short int *top)
3385 yy_stack_print (bottom, top)
3390 YYFPRINTF (stderr, "Stack now");
3391 for (/* Nothing. */; bottom <= top; ++bottom)
3392 YYFPRINTF (stderr, " %d", *bottom);
3393 YYFPRINTF (stderr, "\n");
3396 # define YY_STACK_PRINT(Bottom, Top) \
3399 yy_stack_print ((Bottom), (Top)); \
3403 /*------------------------------------------------.
3404 | Report that the YYRULE is going to be reduced. |
3405 `------------------------------------------------*/
3407 #if defined (__STDC__) || defined (__cplusplus)
3409 yy_reduce_print (int yyrule)
3412 yy_reduce_print (yyrule)
3417 unsigned long int yylno = yyrline[yyrule];
3418 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
3420 /* Print the symbols being reduced, and their result. */
3421 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
3422 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
3423 YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
3426 # define YY_REDUCE_PRINT(Rule) \
3429 yy_reduce_print (Rule); \
3432 /* Nonzero means print parse trace. It is left uninitialized so that
3433 multiple parsers can coexist. */
3435 #else /* !YYDEBUG */
3436 # define YYDPRINTF(Args)
3437 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
3438 # define YY_STACK_PRINT(Bottom, Top)
3439 # define YY_REDUCE_PRINT(Rule)
3440 #endif /* !YYDEBUG */
3443 /* YYINITDEPTH -- initial size of the parser's stacks. */
3445 # define YYINITDEPTH 200
3448 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
3449 if the built-in stack extension method is used).
3451 Do not make this value too large; the results are undefined if
3452 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
3453 evaluated with infinite-precision integer arithmetic. */
3456 # define YYMAXDEPTH 10000
3464 # if defined (__GLIBC__) && defined (_STRING_H)
3465 # define yystrlen strlen
3467 /* Return the length of YYSTR. */
3469 # if defined (__STDC__) || defined (__cplusplus)
3470 yystrlen (const char *yystr)
3476 const char *yys = yystr;
3478 while (*yys++ != '\0')
3481 return yys - yystr - 1;
3487 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
3488 # define yystpcpy stpcpy
3490 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
3493 # if defined (__STDC__) || defined (__cplusplus)
3494 yystpcpy (char *yydest, const char *yysrc)
3496 yystpcpy (yydest, yysrc)
3502 const char *yys = yysrc;
3504 while ((*yyd++ = *yys++) != '\0')
3513 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
3514 quotes and backslashes, so that it's suitable for yyerror. The
3515 heuristic is that double-quoting is unnecessary unless the string
3516 contains an apostrophe, a comma, or backslash (other than
3517 backslash-backslash). YYSTR is taken from yytname. If YYRES is
3518 null, do not copy; instead, return the length of what the result
3521 yytnamerr (char *yyres, const char *yystr)
3526 char const *yyp = yystr;
3533 goto do_not_strip_quotes;
3537 goto do_not_strip_quotes;
3550 do_not_strip_quotes: ;
3554 return yystrlen (yystr);
3556 return yystpcpy (yyres, yystr) - yyres;
3560 #endif /* YYERROR_VERBOSE */
3565 /*--------------------------------.
3566 | Print this symbol on YYOUTPUT. |
3567 `--------------------------------*/
3569 #if defined (__STDC__) || defined (__cplusplus)
3571 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
3574 yysymprint (yyoutput, yytype, yyvaluep)
3580 /* Pacify ``unused variable'' warnings. */
3583 if (yytype < YYNTOKENS)
3584 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
3586 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
3590 if (yytype < YYNTOKENS)
3591 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
3598 YYFPRINTF (yyoutput, ")");
3601 #endif /* ! YYDEBUG */
3602 /*-----------------------------------------------.
3603 | Release the memory associated to this symbol. |
3604 `-----------------------------------------------*/
3606 #if defined (__STDC__) || defined (__cplusplus)
3608 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
3611 yydestruct (yymsg, yytype, yyvaluep)
3617 /* Pacify ``unused variable'' warnings. */
3622 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
3633 /* Prevent warnings from -Wmissing-prototypes. */
3635 #ifdef YYPARSE_PARAM
3636 # if defined (__STDC__) || defined (__cplusplus)
3637 int yyparse (void *YYPARSE_PARAM);
3641 #else /* ! YYPARSE_PARAM */
3642 #if defined (__STDC__) || defined (__cplusplus)
3647 #endif /* ! YYPARSE_PARAM */
3651 /* The look-ahead symbol. */
3654 /* The semantic value of the look-ahead symbol. */
3657 /* Number of syntax errors so far. */
3666 #ifdef YYPARSE_PARAM
3667 # if defined (__STDC__) || defined (__cplusplus)
3668 int yyparse (void *YYPARSE_PARAM)
3670 int yyparse (YYPARSE_PARAM)
3671 void *YYPARSE_PARAM;
3673 #else /* ! YYPARSE_PARAM */
3674 #if defined (__STDC__) || defined (__cplusplus)
3688 /* Number of tokens to shift before error messages enabled. */
3690 /* Look-ahead token as an internal (translated) token number. */
3693 /* Three stacks and their tools:
3694 `yyss': related to states,
3695 `yyvs': related to semantic values,
3696 `yyls': related to locations.
3698 Refer to the stacks thru separate pointers, to allow yyoverflow
3699 to reallocate them elsewhere. */
3701 /* The state stack. */
3702 short int yyssa[YYINITDEPTH];
3703 short int *yyss = yyssa;
3706 /* The semantic value stack. */
3707 YYSTYPE yyvsa[YYINITDEPTH];
3708 YYSTYPE *yyvs = yyvsa;
3713 #define YYPOPSTACK (yyvsp--, yyssp--)
3715 YYSIZE_T yystacksize = YYINITDEPTH;
3717 /* The variables used to return semantic value and location from the
3722 /* When reducing, the number of symbols on the RHS of the reduced
3726 YYDPRINTF ((stderr, "Starting parse\n"));
3731 yychar = YYEMPTY; /* Cause a token to be read. */
3733 /* Initialize stack pointers.
3734 Waste one element of value and location stack
3735 so that they stay on the same level as the state stack.
3736 The wasted elements are never initialized. */
3743 /*------------------------------------------------------------.
3744 | yynewstate -- Push a new state, which is found in yystate. |
3745 `------------------------------------------------------------*/
3747 /* In all cases, when you get here, the value and location stacks
3748 have just been pushed. so pushing a state here evens the stacks.
3755 if (yyss + yystacksize - 1 <= yyssp)
3757 /* Get the current used size of the three stacks, in elements. */
3758 YYSIZE_T yysize = yyssp - yyss + 1;
3762 /* Give user a chance to reallocate the stack. Use copies of
3763 these so that the &'s don't force the real ones into
3765 YYSTYPE *yyvs1 = yyvs;
3766 short int *yyss1 = yyss;
3769 /* Each stack pointer address is followed by the size of the
3770 data in use in that stack, in bytes. This used to be a
3771 conditional around just the two extra args, but that might
3772 be undefined if yyoverflow is a macro. */
3773 yyoverflow (YY_("memory exhausted"),
3774 &yyss1, yysize * sizeof (*yyssp),
3775 &yyvs1, yysize * sizeof (*yyvsp),
3782 #else /* no yyoverflow */
3783 # ifndef YYSTACK_RELOCATE
3784 goto yyexhaustedlab;
3786 /* Extend the stack our own way. */
3787 if (YYMAXDEPTH <= yystacksize)
3788 goto yyexhaustedlab;
3790 if (YYMAXDEPTH < yystacksize)
3791 yystacksize = YYMAXDEPTH;
3794 short int *yyss1 = yyss;
3795 union yyalloc *yyptr =
3796 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
3798 goto yyexhaustedlab;
3799 YYSTACK_RELOCATE (yyss);
3800 YYSTACK_RELOCATE (yyvs);
3802 # undef YYSTACK_RELOCATE
3804 YYSTACK_FREE (yyss1);
3807 #endif /* no yyoverflow */
3809 yyssp = yyss + yysize - 1;
3810 yyvsp = yyvs + yysize - 1;
3813 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
3814 (unsigned long int) yystacksize));
3816 if (yyss + yystacksize - 1 <= yyssp)
3820 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
3829 /* Do appropriate processing given the current state. */
3830 /* Read a look-ahead token if we need one and don't already have one. */
3833 /* First try to decide what to do without reference to look-ahead token. */
3835 yyn = yypact[yystate];
3836 if (yyn == YYPACT_NINF)
3839 /* Not known => get a look-ahead token if don't already have one. */
3841 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
3842 if (yychar == YYEMPTY)
3844 YYDPRINTF ((stderr, "Reading a token: "));
3848 if (yychar <= YYEOF)
3850 yychar = yytoken = YYEOF;
3851 YYDPRINTF ((stderr, "Now at end of input.\n"));
3855 yytoken = YYTRANSLATE (yychar);
3856 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
3859 /* If the proper action on seeing token YYTOKEN is to reduce or to
3860 detect an error, take that action. */
3862 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
3867 if (yyn == 0 || yyn == YYTABLE_NINF)
3876 /* Shift the look-ahead token. */
3877 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
3879 /* Discard the token being shifted unless it is eof. */
3880 if (yychar != YYEOF)
3886 /* Count tokens shifted since error; after three, turn off error
3895 /*-----------------------------------------------------------.
3896 | yydefault -- do the default action for the current state. |
3897 `-----------------------------------------------------------*/
3899 yyn = yydefact[yystate];
3905 /*-----------------------------.
3906 | yyreduce -- Do a reduction. |
3907 `-----------------------------*/
3909 /* yyn is the number of a rule to reduce with. */
3912 /* If YYLEN is nonzero, implement the default value of the action:
3915 Otherwise, the following line sets YYVAL to garbage.
3916 This behavior is undocumented and Bison
3917 users should not rely upon it. Assigning to YYVAL
3918 unconditionally makes the parser a bit smaller, and it avoids a
3919 GCC warning that YYVAL may be used uninitialized. */
3920 yyval = yyvsp[1-yylen];
3923 YY_REDUCE_PRINT (yyn);
3927 #line 1853 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3929 if ((yyvsp[0].UIntVal) > (uint32_t)INT32_MAX) // Outside of my range!
3930 error("Value too large for type");
3931 (yyval.SIntVal) = (int32_t)(yyvsp[0].UIntVal);
3936 #line 1862 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3938 if ((yyvsp[0].UInt64Val) > (uint64_t)INT64_MAX) // Outside of my range!
3939 error("Value too large for type");
3940 (yyval.SInt64Val) = (int64_t)(yyvsp[0].UInt64Val);
3945 #line 1884 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3946 { (yyval.IPred) = ICmpInst::ICMP_EQ; ;}
3950 #line 1884 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3951 { (yyval.IPred) = ICmpInst::ICMP_NE; ;}
3955 #line 1885 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3956 { (yyval.IPred) = ICmpInst::ICMP_SLT; ;}
3960 #line 1885 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3961 { (yyval.IPred) = ICmpInst::ICMP_SGT; ;}
3965 #line 1886 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3966 { (yyval.IPred) = ICmpInst::ICMP_SLE; ;}
3970 #line 1886 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3971 { (yyval.IPred) = ICmpInst::ICMP_SGE; ;}
3975 #line 1887 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3976 { (yyval.IPred) = ICmpInst::ICMP_ULT; ;}
3980 #line 1887 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3981 { (yyval.IPred) = ICmpInst::ICMP_UGT; ;}
3985 #line 1888 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3986 { (yyval.IPred) = ICmpInst::ICMP_ULE; ;}
3990 #line 1888 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3991 { (yyval.IPred) = ICmpInst::ICMP_UGE; ;}
3995 #line 1892 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3996 { (yyval.FPred) = FCmpInst::FCMP_OEQ; ;}
4000 #line 1892 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4001 { (yyval.FPred) = FCmpInst::FCMP_ONE; ;}
4005 #line 1893 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4006 { (yyval.FPred) = FCmpInst::FCMP_OLT; ;}
4010 #line 1893 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4011 { (yyval.FPred) = FCmpInst::FCMP_OGT; ;}
4015 #line 1894 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4016 { (yyval.FPred) = FCmpInst::FCMP_OLE; ;}
4020 #line 1894 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4021 { (yyval.FPred) = FCmpInst::FCMP_OGE; ;}
4025 #line 1895 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4026 { (yyval.FPred) = FCmpInst::FCMP_ORD; ;}
4030 #line 1895 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4031 { (yyval.FPred) = FCmpInst::FCMP_UNO; ;}
4035 #line 1896 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4036 { (yyval.FPred) = FCmpInst::FCMP_UEQ; ;}
4040 #line 1896 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4041 { (yyval.FPred) = FCmpInst::FCMP_UNE; ;}
4045 #line 1897 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4046 { (yyval.FPred) = FCmpInst::FCMP_ULT; ;}
4050 #line 1897 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4051 { (yyval.FPred) = FCmpInst::FCMP_UGT; ;}
4055 #line 1898 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4056 { (yyval.FPred) = FCmpInst::FCMP_ULE; ;}
4060 #line 1898 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4061 { (yyval.FPred) = FCmpInst::FCMP_UGE; ;}
4065 #line 1899 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4066 { (yyval.FPred) = FCmpInst::FCMP_TRUE; ;}
4070 #line 1900 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4071 { (yyval.FPred) = FCmpInst::FCMP_FALSE; ;}
4075 #line 1931 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4077 (yyval.StrVal) = (yyvsp[-1].StrVal);
4082 #line 1934 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4089 #line 1939 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4090 { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
4094 #line 1940 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4095 { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
4099 #line 1941 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4100 { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
4104 #line 1942 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4105 { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;}
4109 #line 1943 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4110 { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
4114 #line 1944 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4115 { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
4119 #line 1945 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4120 { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
4124 #line 1946 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4125 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
4129 #line 1950 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4130 { (yyval.UIntVal) = OldCallingConv::C; ;}
4134 #line 1951 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4135 { (yyval.UIntVal) = OldCallingConv::C; ;}
4139 #line 1952 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4140 { (yyval.UIntVal) = OldCallingConv::CSRet; ;}
4144 #line 1953 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4145 { (yyval.UIntVal) = OldCallingConv::Fast; ;}
4149 #line 1954 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4150 { (yyval.UIntVal) = OldCallingConv::Cold; ;}
4154 #line 1955 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4155 { (yyval.UIntVal) = OldCallingConv::X86_StdCall; ;}
4159 #line 1956 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4160 { (yyval.UIntVal) = OldCallingConv::X86_FastCall; ;}
4164 #line 1957 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4166 if ((unsigned)(yyvsp[0].UInt64Val) != (yyvsp[0].UInt64Val))
4167 error("Calling conv too large");
4168 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
4173 #line 1967 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4174 { (yyval.UIntVal) = 0; ;}
4178 #line 1968 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4180 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
4181 if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
4182 error("Alignment must be a power of two");
4187 #line 1976 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4188 { (yyval.UIntVal) = 0; ;}
4192 #line 1977 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4194 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
4195 if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
4196 error("Alignment must be a power of two");
4201 #line 1985 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4203 for (unsigned i = 0, e = strlen((yyvsp[0].StrVal)); i != e; ++i)
4204 if ((yyvsp[0].StrVal)[i] == '"' || (yyvsp[0].StrVal)[i] == '\\')
4205 error("Invalid character in section name");
4206 (yyval.StrVal) = (yyvsp[0].StrVal);
4211 #line 1994 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4212 { (yyval.StrVal) = 0; ;}
4216 #line 1995 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4217 { (yyval.StrVal) = (yyvsp[0].StrVal); ;}
4221 #line 2002 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4226 #line 2003 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4231 #line 2007 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4233 CurGV->setSection((yyvsp[0].StrVal));
4234 free((yyvsp[0].StrVal));
4239 #line 2011 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4241 if ((yyvsp[0].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[0].UInt64Val)))
4242 error("Alignment must be a power of two");
4243 CurGV->setAlignment((yyvsp[0].UInt64Val));
4249 #line 2028 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4251 (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T);
4252 (yyval.TypeVal).S.makeSignless();
4257 #line 2036 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4259 (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T);
4260 (yyval.TypeVal).S.makeSignless();
4265 #line 2043 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4267 if (!UpRefs.empty())
4268 error("Invalid upreference in type: " + (*(yyvsp[0].TypeVal).PAT)->getDescription());
4269 (yyval.TypeVal) = (yyvsp[0].TypeVal);
4274 #line 2057 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4276 (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T);
4277 (yyval.TypeVal).S.copy((yyvsp[0].PrimType).S);
4282 #line 2061 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4284 (yyval.TypeVal).PAT = new PATypeHolder(OpaqueType::get());
4285 (yyval.TypeVal).S.makeSignless();
4290 #line 2065 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4291 { // Named types are also simple types...
4292 (yyval.TypeVal).S.copy(getTypeSign((yyvsp[0].ValIDVal)));
4293 const Type* tmp = getType((yyvsp[0].ValIDVal));
4294 (yyval.TypeVal).PAT = new PATypeHolder(tmp);
4299 #line 2070 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4300 { // Type UpReference
4301 if ((yyvsp[0].UInt64Val) > (uint64_t)~0U)
4302 error("Value out of range");
4303 OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder
4304 UpRefs.push_back(UpRefRecord((unsigned)(yyvsp[0].UInt64Val), OT)); // Add to vector...
4305 (yyval.TypeVal).PAT = new PATypeHolder(OT);
4306 (yyval.TypeVal).S.makeSignless();
4307 UR_OUT("New Upreference!\n");
4312 #line 2079 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4313 { // Function derived type?
4314 (yyval.TypeVal).S.makeComposite((yyvsp[-3].TypeVal).S);
4315 std::vector<const Type*> Params;
4316 for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-1].TypeList)->begin(),
4317 E = (yyvsp[-1].TypeList)->end(); I != E; ++I) {
4318 Params.push_back(I->PAT->get());
4319 (yyval.TypeVal).S.add(I->S);
4321 FunctionType::ParamAttrsList ParamAttrs;
4322 bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
4323 if (isVarArg) Params.pop_back();
4325 (yyval.TypeVal).PAT = new PATypeHolder(
4326 HandleUpRefs(FunctionType::get((yyvsp[-3].TypeVal).PAT->get(), Params, isVarArg,
4327 ParamAttrs), (yyval.TypeVal).S));
4328 delete (yyvsp[-3].TypeVal).PAT; // Delete the return type handle
4329 delete (yyvsp[-1].TypeList); // Delete the argument list
4334 #line 2097 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4335 { // Sized array type?
4336 (yyval.TypeVal).S.makeComposite((yyvsp[-1].TypeVal).S);
4337 (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(ArrayType::get((yyvsp[-1].TypeVal).PAT->get(),
4338 (unsigned)(yyvsp[-3].UInt64Val)), (yyval.TypeVal).S));
4339 delete (yyvsp[-1].TypeVal).PAT;
4344 #line 2103 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4346 const llvm::Type* ElemTy = (yyvsp[-1].TypeVal).PAT->get();
4347 if ((unsigned)(yyvsp[-3].UInt64Val) != (yyvsp[-3].UInt64Val))
4348 error("Unsigned result not equal to signed result");
4349 if (!(ElemTy->isInteger() || ElemTy->isFloatingPoint()))
4350 error("Elements of a VectorType must be integer or floating point");
4351 if (!isPowerOf2_32((yyvsp[-3].UInt64Val)))
4352 error("VectorType length should be a power of 2");
4353 (yyval.TypeVal).S.makeComposite((yyvsp[-1].TypeVal).S);
4354 (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(VectorType::get(ElemTy,
4355 (unsigned)(yyvsp[-3].UInt64Val)), (yyval.TypeVal).S));
4356 delete (yyvsp[-1].TypeVal).PAT;
4361 #line 2116 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4362 { // Structure type?
4363 std::vector<const Type*> Elements;
4364 (yyval.TypeVal).S.makeComposite();
4365 for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-1].TypeList)->begin(),
4366 E = (yyvsp[-1].TypeList)->end(); I != E; ++I) {
4367 Elements.push_back(I->PAT->get());
4368 (yyval.TypeVal).S.add(I->S);
4370 (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(StructType::get(Elements), (yyval.TypeVal).S));
4371 delete (yyvsp[-1].TypeList);
4376 #line 2127 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4377 { // Empty structure type?
4378 (yyval.TypeVal).PAT = new PATypeHolder(StructType::get(std::vector<const Type*>()));
4379 (yyval.TypeVal).S.makeComposite();
4384 #line 2131 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4385 { // Packed Structure type?
4386 (yyval.TypeVal).S.makeComposite();
4387 std::vector<const Type*> Elements;
4388 for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-2].TypeList)->begin(),
4389 E = (yyvsp[-2].TypeList)->end(); I != E; ++I) {
4390 Elements.push_back(I->PAT->get());
4391 (yyval.TypeVal).S.add(I->S);
4394 (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true),
4395 (yyval.TypeVal).S));
4396 delete (yyvsp[-2].TypeList);
4401 #line 2144 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4402 { // Empty packed structure type?
4403 (yyval.TypeVal).PAT = new PATypeHolder(StructType::get(std::vector<const Type*>(),true));
4404 (yyval.TypeVal).S.makeComposite();
4409 #line 2148 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4411 if ((yyvsp[-1].TypeVal).PAT->get() == Type::LabelTy)
4412 error("Cannot form a pointer to a basic block");
4413 (yyval.TypeVal).S.makeComposite((yyvsp[-1].TypeVal).S);
4414 (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(PointerType::get((yyvsp[-1].TypeVal).PAT->get()),
4415 (yyval.TypeVal).S));
4416 delete (yyvsp[-1].TypeVal).PAT;
4421 #line 2162 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4423 (yyval.TypeList) = new std::list<PATypeInfo>();
4424 (yyval.TypeList)->push_back((yyvsp[0].TypeVal));
4429 #line 2166 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4431 ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back((yyvsp[0].TypeVal));
4436 #line 2174 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4439 VoidTI.PAT = new PATypeHolder(Type::VoidTy);
4440 VoidTI.S.makeSignless();
4441 ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back(VoidTI);
4446 #line 2180 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4448 (yyval.TypeList) = new std::list<PATypeInfo>();
4450 VoidTI.PAT = new PATypeHolder(Type::VoidTy);
4451 VoidTI.S.makeSignless();
4452 (yyval.TypeList)->push_back(VoidTI);
4457 #line 2187 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4459 (yyval.TypeList) = new std::list<PATypeInfo>();
4464 #line 2199 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4465 { // Nonempty unsized arr
4466 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-3].TypeVal).PAT->get());
4468 error("Cannot make array constant with type: '" +
4469 (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'");
4470 const Type *ETy = ATy->getElementType();
4471 int NumElements = ATy->getNumElements();
4473 // Verify that we have the correct size...
4474 if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
4475 error("Type mismatch: constant sized array initialized with " +
4476 utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " +
4477 itostr(NumElements) + "");
4479 // Verify all elements are correct type!
4480 std::vector<Constant*> Elems;
4481 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
4482 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4483 const Type* ValTy = C->getType();
4485 error("Element #" + utostr(i) + " is not of type '" +
4486 ETy->getDescription() +"' as required!\nIt is of type '"+
4487 ValTy->getDescription() + "'");
4490 (yyval.ConstVal).C = ConstantArray::get(ATy, Elems);
4491 (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S);
4492 delete (yyvsp[-3].TypeVal).PAT;
4493 delete (yyvsp[-1].ConstVector);
4498 #line 2229 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4500 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-2].TypeVal).PAT->get());
4502 error("Cannot make array constant with type: '" +
4503 (yyvsp[-2].TypeVal).PAT->get()->getDescription() + "'");
4504 int NumElements = ATy->getNumElements();
4505 if (NumElements != -1 && NumElements != 0)
4506 error("Type mismatch: constant sized array initialized with 0"
4507 " arguments, but has size of " + itostr(NumElements) +"");
4508 (yyval.ConstVal).C = ConstantArray::get(ATy, std::vector<Constant*>());
4509 (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S);
4510 delete (yyvsp[-2].TypeVal).PAT;
4515 #line 2242 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4517 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-2].TypeVal).PAT->get());
4519 error("Cannot make array constant with type: '" +
4520 (yyvsp[-2].TypeVal).PAT->get()->getDescription() + "'");
4521 int NumElements = ATy->getNumElements();
4522 const Type *ETy = dyn_cast<IntegerType>(ATy->getElementType());
4523 if (!ETy || cast<IntegerType>(ETy)->getBitWidth() != 8)
4524 error("String arrays require type i8, not '" + ETy->getDescription() +
4526 char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
4527 if (NumElements != -1 && NumElements != (EndStr-(yyvsp[0].StrVal)))
4528 error("Can't build string constant of size " +
4529 itostr((int)(EndStr-(yyvsp[0].StrVal))) + " when array has size " +
4530 itostr(NumElements) + "");
4531 std::vector<Constant*> Vals;
4532 for (char *C = (char *)(yyvsp[0].StrVal); C != (char *)EndStr; ++C)
4533 Vals.push_back(ConstantInt::get(ETy, *C));
4534 free((yyvsp[0].StrVal));
4535 (yyval.ConstVal).C = ConstantArray::get(ATy, Vals);
4536 (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S);
4537 delete (yyvsp[-2].TypeVal).PAT;
4542 #line 2265 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4543 { // Nonempty unsized arr
4544 const VectorType *PTy = dyn_cast<VectorType>((yyvsp[-3].TypeVal).PAT->get());
4546 error("Cannot make packed constant with type: '" +
4547 (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'");
4548 const Type *ETy = PTy->getElementType();
4549 int NumElements = PTy->getNumElements();
4550 // Verify that we have the correct size...
4551 if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
4552 error("Type mismatch: constant sized packed initialized with " +
4553 utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " +
4554 itostr(NumElements) + "");
4555 // Verify all elements are correct type!
4556 std::vector<Constant*> Elems;
4557 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
4558 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4559 const Type* ValTy = C->getType();
4561 error("Element #" + utostr(i) + " is not of type '" +
4562 ETy->getDescription() +"' as required!\nIt is of type '"+
4563 ValTy->getDescription() + "'");
4566 (yyval.ConstVal).C = ConstantVector::get(PTy, Elems);
4567 (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S);
4568 delete (yyvsp[-3].TypeVal).PAT;
4569 delete (yyvsp[-1].ConstVector);
4574 #line 2293 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4576 const StructType *STy = dyn_cast<StructType>((yyvsp[-3].TypeVal).PAT->get());
4578 error("Cannot make struct constant with type: '" +
4579 (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'");
4580 if ((yyvsp[-1].ConstVector)->size() != STy->getNumContainedTypes())
4581 error("Illegal number of initializers for structure type");
4583 // Check to ensure that constants are compatible with the type initializer!
4584 std::vector<Constant*> Fields;
4585 for (unsigned i = 0, e = (yyvsp[-1].ConstVector)->size(); i != e; ++i) {
4586 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4587 if (C->getType() != STy->getElementType(i))
4588 error("Expected type '" + STy->getElementType(i)->getDescription() +
4589 "' for element #" + utostr(i) + " of structure initializer");
4590 Fields.push_back(C);
4592 (yyval.ConstVal).C = ConstantStruct::get(STy, Fields);
4593 (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S);
4594 delete (yyvsp[-3].TypeVal).PAT;
4595 delete (yyvsp[-1].ConstVector);
4600 #line 2315 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4602 const StructType *STy = dyn_cast<StructType>((yyvsp[-2].TypeVal).PAT->get());
4604 error("Cannot make struct constant with type: '" +
4605 (yyvsp[-2].TypeVal).PAT->get()->getDescription() + "'");
4606 if (STy->getNumContainedTypes() != 0)
4607 error("Illegal number of initializers for structure type");
4608 (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector<Constant*>());
4609 (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S);
4610 delete (yyvsp[-2].TypeVal).PAT;
4615 #line 2326 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4617 const StructType *STy = dyn_cast<StructType>((yyvsp[-5].TypeVal).PAT->get());
4619 error("Cannot make packed struct constant with type: '" +
4620 (yyvsp[-5].TypeVal).PAT->get()->getDescription() + "'");
4621 if ((yyvsp[-2].ConstVector)->size() != STy->getNumContainedTypes())
4622 error("Illegal number of initializers for packed structure type");
4624 // Check to ensure that constants are compatible with the type initializer!
4625 std::vector<Constant*> Fields;
4626 for (unsigned i = 0, e = (yyvsp[-2].ConstVector)->size(); i != e; ++i) {
4627 Constant *C = (*(yyvsp[-2].ConstVector))[i].C;
4628 if (C->getType() != STy->getElementType(i))
4629 error("Expected type '" + STy->getElementType(i)->getDescription() +
4630 "' for element #" + utostr(i) + " of packed struct initializer");
4631 Fields.push_back(C);
4633 (yyval.ConstVal).C = ConstantStruct::get(STy, Fields);
4634 (yyval.ConstVal).S.copy((yyvsp[-5].TypeVal).S);
4635 delete (yyvsp[-5].TypeVal).PAT;
4636 delete (yyvsp[-2].ConstVector);
4641 #line 2348 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4643 const StructType *STy = dyn_cast<StructType>((yyvsp[-4].TypeVal).PAT->get());
4645 error("Cannot make packed struct constant with type: '" +
4646 (yyvsp[-4].TypeVal).PAT->get()->getDescription() + "'");
4647 if (STy->getNumContainedTypes() != 0)
4648 error("Illegal number of initializers for packed structure type");
4649 (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector<Constant*>());
4650 (yyval.ConstVal).S.copy((yyvsp[-4].TypeVal).S);
4651 delete (yyvsp[-4].TypeVal).PAT;
4656 #line 2359 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4658 const PointerType *PTy = dyn_cast<PointerType>((yyvsp[-1].TypeVal).PAT->get());
4660 error("Cannot make null pointer constant with type: '" +
4661 (yyvsp[-1].TypeVal).PAT->get()->getDescription() + "'");
4662 (yyval.ConstVal).C = ConstantPointerNull::get(PTy);
4663 (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
4664 delete (yyvsp[-1].TypeVal).PAT;
4669 #line 2368 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4671 (yyval.ConstVal).C = UndefValue::get((yyvsp[-1].TypeVal).PAT->get());
4672 (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
4673 delete (yyvsp[-1].TypeVal).PAT;
4678 #line 2373 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4680 const PointerType *Ty = dyn_cast<PointerType>((yyvsp[-1].TypeVal).PAT->get());
4682 error("Global const reference must be a pointer type, not" +
4683 (yyvsp[-1].TypeVal).PAT->get()->getDescription());
4685 // ConstExprs can exist in the body of a function, thus creating
4686 // GlobalValues whenever they refer to a variable. Because we are in
4687 // the context of a function, getExistingValue will search the functions
4688 // symbol table instead of the module symbol table for the global symbol,
4689 // which throws things all off. To get around this, we just tell
4690 // getExistingValue that we are at global scope here.
4692 Function *SavedCurFn = CurFun.CurrentFunction;
4693 CurFun.CurrentFunction = 0;
4694 (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S);
4695 Value *V = getExistingValue(Ty, (yyvsp[0].ValIDVal));
4696 CurFun.CurrentFunction = SavedCurFn;
4698 // If this is an initializer for a constant pointer, which is referencing a
4699 // (currently) undefined variable, create a stub now that shall be replaced
4700 // in the future with the right type of variable.
4703 assert(isa<PointerType>(Ty) && "Globals may only be used as pointers");
4704 const PointerType *PT = cast<PointerType>(Ty);
4706 // First check to see if the forward references value is already created!
4707 PerModuleInfo::GlobalRefsType::iterator I =
4708 CurModule.GlobalRefs.find(std::make_pair(PT, (yyvsp[0].ValIDVal)));
4710 if (I != CurModule.GlobalRefs.end()) {
4711 V = I->second; // Placeholder already exists, use it...
4712 (yyvsp[0].ValIDVal).destroy();
4715 if ((yyvsp[0].ValIDVal).Type == ValID::NameVal) Name = (yyvsp[0].ValIDVal).Name;
4717 // Create the forward referenced global.
4719 if (const FunctionType *FTy =
4720 dyn_cast<FunctionType>(PT->getElementType())) {
4721 GV = new Function(FTy, GlobalValue::ExternalLinkage, Name,
4722 CurModule.CurrentModule);
4724 GV = new GlobalVariable(PT->getElementType(), false,
4725 GlobalValue::ExternalLinkage, 0,
4726 Name, CurModule.CurrentModule);
4729 // Keep track of the fact that we have a forward ref to recycle it
4730 CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, (yyvsp[0].ValIDVal)), GV));
4734 (yyval.ConstVal).C = cast<GlobalValue>(V);
4735 (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
4736 delete (yyvsp[-1].TypeVal).PAT; // Free the type handle
4741 #line 2432 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4743 if ((yyvsp[-1].TypeVal).PAT->get() != (yyvsp[0].ConstVal).C->getType())
4744 error("Mismatched types for constant expression");
4745 (yyval.ConstVal) = (yyvsp[0].ConstVal);
4746 (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
4747 delete (yyvsp[-1].TypeVal).PAT;
4752 #line 2439 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4754 const Type *Ty = (yyvsp[-1].TypeVal).PAT->get();
4755 if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty))
4756 error("Cannot create a null initialized value of this type");
4757 (yyval.ConstVal).C = Constant::getNullValue(Ty);
4758 (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
4759 delete (yyvsp[-1].TypeVal).PAT;
4764 #line 2447 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4765 { // integral constants
4766 const Type *Ty = (yyvsp[-1].PrimType).T;
4767 if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].SInt64Val)))
4768 error("Constant value doesn't fit in type");
4769 (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].SInt64Val));
4770 (yyval.ConstVal).S.makeSigned();
4775 #line 2454 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4776 { // integral constants
4777 const Type *Ty = (yyvsp[-1].PrimType).T;
4778 if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].UInt64Val)))
4779 error("Constant value doesn't fit in type");
4780 (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].UInt64Val));
4781 (yyval.ConstVal).S.makeUnsigned();
4786 #line 2461 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4787 { // Boolean constants
4788 (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, true);
4789 (yyval.ConstVal).S.makeUnsigned();
4794 #line 2465 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4795 { // Boolean constants
4796 (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, false);
4797 (yyval.ConstVal).S.makeUnsigned();
4802 #line 2469 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4803 { // Float & Double constants
4804 if (!ConstantFP::isValueValidForType((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal)))
4805 error("Floating point constant invalid for type");
4806 (yyval.ConstVal).C = ConstantFP::get((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal));
4807 (yyval.ConstVal).S.makeSignless();
4812 #line 2478 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4814 const Type* SrcTy = (yyvsp[-3].ConstVal).C->getType();
4815 const Type* DstTy = (yyvsp[-1].TypeVal).PAT->get();
4816 Signedness SrcSign((yyvsp[-3].ConstVal).S);
4817 Signedness DstSign((yyvsp[-1].TypeVal).S);
4818 if (!SrcTy->isFirstClassType())
4819 error("cast constant expression from a non-primitive type: '" +
4820 SrcTy->getDescription() + "'");
4821 if (!DstTy->isFirstClassType())
4822 error("cast constant expression to a non-primitive type: '" +
4823 DstTy->getDescription() + "'");
4824 (yyval.ConstVal).C = cast<Constant>(getCast((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal).C, SrcSign, DstTy, DstSign));
4825 (yyval.ConstVal).S.copy(DstSign);
4826 delete (yyvsp[-1].TypeVal).PAT;
4831 #line 2493 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4833 const Type *Ty = (yyvsp[-2].ConstVal).C->getType();
4834 if (!isa<PointerType>(Ty))
4835 error("GetElementPtr requires a pointer operand");
4837 std::vector<Value*> VIndices;
4838 std::vector<Constant*> CIndices;
4839 upgradeGEPIndices((yyvsp[-2].ConstVal).C->getType(), (yyvsp[-1].ValueList), VIndices, &CIndices);
4841 delete (yyvsp[-1].ValueList);
4842 (yyval.ConstVal).C = ConstantExpr::getGetElementPtr((yyvsp[-2].ConstVal).C, &CIndices[0], CIndices.size());
4843 (yyval.ConstVal).S.copy(getElementSign((yyvsp[-2].ConstVal), CIndices));
4848 #line 2506 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4850 if (!(yyvsp[-5].ConstVal).C->getType()->isInteger() ||
4851 cast<IntegerType>((yyvsp[-5].ConstVal).C->getType())->getBitWidth() != 1)
4852 error("Select condition must be bool type");
4853 if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4854 error("Select operand types must match");
4855 (yyval.ConstVal).C = ConstantExpr::getSelect((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4856 (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S);
4861 #line 2515 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4863 const Type *Ty = (yyvsp[-3].ConstVal).C->getType();
4864 if (Ty != (yyvsp[-1].ConstVal).C->getType())
4865 error("Binary operator types must match");
4866 // First, make sure we're dealing with the right opcode by upgrading from
4867 // obsolete versions.
4868 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S);
4870 // HACK: llvm 1.3 and earlier used to emit invalid pointer constant exprs.
4871 // To retain backward compatibility with these early compilers, we emit a
4872 // cast to the appropriate integer type automatically if we are in the
4873 // broken case. See PR424 for more information.
4874 if (!isa<PointerType>(Ty)) {
4875 (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4877 const Type *IntPtrTy = 0;
4878 switch (CurModule.CurrentModule->getPointerSize()) {
4879 case Module::Pointer32: IntPtrTy = Type::Int32Ty; break;
4880 case Module::Pointer64: IntPtrTy = Type::Int64Ty; break;
4881 default: error("invalid pointer binary constant expr");
4883 (yyval.ConstVal).C = ConstantExpr::get(Opcode,
4884 ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-3].ConstVal).C, IntPtrTy),
4885 ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-1].ConstVal).C, IntPtrTy));
4886 (yyval.ConstVal).C = ConstantExpr::getCast(Instruction::IntToPtr, (yyval.ConstVal).C, Ty);
4888 (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S);
4893 #line 2543 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4895 const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4896 if (Ty != (yyvsp[-1].ConstVal).C->getType())
4897 error("Logical operator types must match");
4898 if (!Ty->isInteger()) {
4899 if (!isa<VectorType>(Ty) ||
4900 !cast<VectorType>(Ty)->getElementType()->isInteger())
4901 error("Logical operator requires integer operands");
4903 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S);
4904 (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4905 (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S);
4910 #line 2556 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4912 const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4913 if (Ty != (yyvsp[-1].ConstVal).C->getType())
4914 error("setcc operand types must match");
4915 unsigned short pred;
4916 Instruction::OtherOps Opcode = getCompareOp((yyvsp[-5].BinaryOpVal), pred, Ty, (yyvsp[-3].ConstVal).S);
4917 (yyval.ConstVal).C = ConstantExpr::getCompare(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4918 (yyval.ConstVal).S.makeUnsigned();
4923 #line 2565 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4925 if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4926 error("icmp operand types must match");
4927 (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].IPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4928 (yyval.ConstVal).S.makeUnsigned();
4933 #line 2571 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4935 if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4936 error("fcmp operand types must match");
4937 (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].FPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4938 (yyval.ConstVal).S.makeUnsigned();
4943 #line 2577 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4945 if (!(yyvsp[-1].ConstVal).C->getType()->isInteger() ||
4946 cast<IntegerType>((yyvsp[-1].ConstVal).C->getType())->getBitWidth() != 8)
4947 error("Shift count for shift constant must be unsigned byte");
4948 const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4949 if (!(yyvsp[-3].ConstVal).C->getType()->isInteger())
4950 error("Shift constant expression requires integer operand");
4951 Constant *ShiftAmt = ConstantExpr::getZExt((yyvsp[-1].ConstVal).C, Ty);
4952 (yyval.ConstVal).C = ConstantExpr::get(getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S), (yyvsp[-3].ConstVal).C, ShiftAmt);
4953 (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S);
4958 #line 2588 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4960 if (!ExtractElementInst::isValidOperands((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4961 error("Invalid extractelement operands");
4962 (yyval.ConstVal).C = ConstantExpr::getExtractElement((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4963 (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S.get(0));
4968 #line 2594 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4970 if (!InsertElementInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4971 error("Invalid insertelement operands");
4972 (yyval.ConstVal).C = ConstantExpr::getInsertElement((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4973 (yyval.ConstVal).S.copy((yyvsp[-5].ConstVal).S);
4978 #line 2600 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4980 if (!ShuffleVectorInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4981 error("Invalid shufflevector operands");
4982 (yyval.ConstVal).C = ConstantExpr::getShuffleVector((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4983 (yyval.ConstVal).S.copy((yyvsp[-5].ConstVal).S);
4988 #line 2611 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4989 { ((yyval.ConstVector) = (yyvsp[-2].ConstVector))->push_back((yyvsp[0].ConstVal)); ;}
4993 #line 2612 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4995 (yyval.ConstVector) = new std::vector<ConstInfo>();
4996 (yyval.ConstVector)->push_back((yyvsp[0].ConstVal));
5001 #line 2621 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5002 { (yyval.BoolVal) = false; ;}
5006 #line 2622 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5007 { (yyval.BoolVal) = true; ;}
5011 #line 2634 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5013 (yyval.ModuleVal) = ParserResult = (yyvsp[0].ModuleVal);
5014 CurModule.ModuleDone();
5019 #line 2643 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5020 { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); CurFun.FunctionDone(); ;}
5024 #line 2644 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5025 { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;}
5029 #line 2645 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5030 { (yyval.ModuleVal) = (yyvsp[-3].ModuleVal); ;}
5034 #line 2646 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5035 { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;}
5039 #line 2647 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5041 (yyval.ModuleVal) = CurModule.CurrentModule;
5042 // Emit an error if there are any unresolved types left.
5043 if (!CurModule.LateResolveTypes.empty()) {
5044 const ValID &DID = CurModule.LateResolveTypes.begin()->first;
5045 if (DID.Type == ValID::NameVal) {
5046 error("Reference to an undefined type: '"+DID.getName() + "'");
5048 error("Reference to an undefined type: #" + itostr(DID.Num));
5055 #line 2663 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5057 // Eagerly resolve types. This is not an optimization, this is a
5058 // requirement that is due to the fact that we could have this:
5060 // %list = type { %list * }
5061 // %list = type { %list * } ; repeated type decl
5063 // If types are not resolved eagerly, then the two types will not be
5064 // determined to be the same type!
5066 ResolveTypeTo((yyvsp[-2].StrVal), (yyvsp[0].TypeVal).PAT->get(), (yyvsp[0].TypeVal).S);
5068 if (!setTypeName((yyvsp[0].TypeVal), (yyvsp[-2].StrVal)) && !(yyvsp[-2].StrVal)) {
5069 // If this is a numbered type that is not a redefinition, add it to the
5071 CurModule.Types.push_back((yyvsp[0].TypeVal).PAT->get());
5072 CurModule.TypeSigns.push_back((yyvsp[0].TypeVal).S);
5074 delete (yyvsp[0].TypeVal).PAT;
5079 #line 2683 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5080 { // Function prototypes can be in const pool
5085 #line 2685 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5086 { // Asm blocks can be in the const pool
5091 #line 2687 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5093 if ((yyvsp[0].ConstVal).C == 0)
5094 error("Global value initializer is not a constant");
5095 CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), (yyvsp[-2].Linkage), (yyvsp[-1].BoolVal), (yyvsp[0].ConstVal).C->getType(), (yyvsp[0].ConstVal).C, (yyvsp[0].ConstVal).S);
5100 #line 2691 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5107 #line 2694 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5109 const Type *Ty = (yyvsp[0].TypeVal).PAT->get();
5110 CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalLinkage, (yyvsp[-1].BoolVal), Ty, 0,
5111 (yyvsp[0].TypeVal).S);
5112 delete (yyvsp[0].TypeVal).PAT;
5117 #line 2699 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5124 #line 2702 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5126 const Type *Ty = (yyvsp[0].TypeVal).PAT->get();
5127 CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::DLLImportLinkage, (yyvsp[-1].BoolVal), Ty, 0,
5128 (yyvsp[0].TypeVal).S);
5129 delete (yyvsp[0].TypeVal).PAT;
5134 #line 2707 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5141 #line 2710 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5143 const Type *Ty = (yyvsp[0].TypeVal).PAT->get();
5145 ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalWeakLinkage, (yyvsp[-1].BoolVal), Ty, 0,
5146 (yyvsp[0].TypeVal).S);
5147 delete (yyvsp[0].TypeVal).PAT;
5152 #line 2716 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5159 #line 2719 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5165 #line 2721 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5171 #line 2723 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5177 #line 2728 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5179 const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
5180 char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
5181 std::string NewAsm((yyvsp[0].StrVal), EndStr);
5182 free((yyvsp[0].StrVal));
5184 if (AsmSoFar.empty())
5185 CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
5187 CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
5192 #line 2742 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5193 { (yyval.Endianness) = Module::BigEndian; ;}
5197 #line 2743 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5198 { (yyval.Endianness) = Module::LittleEndian; ;}
5202 #line 2747 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5204 CurModule.setEndianness((yyvsp[0].Endianness));
5209 #line 2750 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5211 if ((yyvsp[0].UInt64Val) == 32)
5212 CurModule.setPointerSize(Module::Pointer32);
5213 else if ((yyvsp[0].UInt64Val) == 64)
5214 CurModule.setPointerSize(Module::Pointer64);
5216 error("Invalid pointer size: '" + utostr((yyvsp[0].UInt64Val)) + "'");
5221 #line 2758 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5223 CurModule.CurrentModule->setTargetTriple((yyvsp[0].StrVal));
5224 free((yyvsp[0].StrVal));
5229 #line 2762 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5231 CurModule.CurrentModule->setDataLayout((yyvsp[0].StrVal));
5232 free((yyvsp[0].StrVal));
5237 #line 2773 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5239 CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
5240 free((yyvsp[0].StrVal));
5245 #line 2777 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5247 CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
5248 free((yyvsp[0].StrVal));
5253 #line 2781 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5258 #line 2794 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5259 { (yyval.StrVal) = 0; ;}
5263 #line 2798 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5265 if ((yyvsp[-1].TypeVal).PAT->get() == Type::VoidTy)
5266 error("void typed arguments are invalid");
5267 (yyval.ArgVal) = new std::pair<PATypeInfo, char*>((yyvsp[-1].TypeVal), (yyvsp[0].StrVal));
5272 #line 2806 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5274 (yyval.ArgList) = (yyvsp[-2].ArgList);
5275 (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal));
5276 delete (yyvsp[0].ArgVal);
5281 #line 2811 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5283 (yyval.ArgList) = new std::vector<std::pair<PATypeInfo,char*> >();
5284 (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal));
5285 delete (yyvsp[0].ArgVal);
5290 #line 2819 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5291 { (yyval.ArgList) = (yyvsp[0].ArgList); ;}
5295 #line 2820 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5297 (yyval.ArgList) = (yyvsp[-2].ArgList);
5299 VoidTI.PAT = new PATypeHolder(Type::VoidTy);
5300 VoidTI.S.makeSignless();
5301 (yyval.ArgList)->push_back(std::pair<PATypeInfo, char*>(VoidTI, 0));
5306 #line 2827 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5308 (yyval.ArgList) = new std::vector<std::pair<PATypeInfo,char*> >();
5310 VoidTI.PAT = new PATypeHolder(Type::VoidTy);
5311 VoidTI.S.makeSignless();
5312 (yyval.ArgList)->push_back(std::pair<PATypeInfo, char*>(VoidTI, 0));
5317 #line 2834 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5318 { (yyval.ArgList) = 0; ;}
5322 #line 2838 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5324 UnEscapeLexed((yyvsp[-5].StrVal));
5325 std::string FunctionName((yyvsp[-5].StrVal));
5326 free((yyvsp[-5].StrVal)); // Free strdup'd memory!
5328 const Type* RetTy = (yyvsp[-6].TypeVal).PAT->get();
5330 if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
5331 error("LLVM functions cannot return aggregate types");
5334 FTySign.makeComposite((yyvsp[-6].TypeVal).S);
5335 std::vector<const Type*> ParamTyList;
5337 // In LLVM 2.0 the signatures of three varargs intrinsics changed to take
5338 // i8*. We check here for those names and override the parameter list
5339 // types to ensure the prototype is correct.
5340 if (FunctionName == "llvm.va_start" || FunctionName == "llvm.va_end") {
5341 ParamTyList.push_back(PointerType::get(Type::Int8Ty));
5342 } else if (FunctionName == "llvm.va_copy") {
5343 ParamTyList.push_back(PointerType::get(Type::Int8Ty));
5344 ParamTyList.push_back(PointerType::get(Type::Int8Ty));
5345 } else if ((yyvsp[-3].ArgList)) { // If there are arguments...
5346 for (std::vector<std::pair<PATypeInfo,char*> >::iterator
5347 I = (yyvsp[-3].ArgList)->begin(), E = (yyvsp[-3].ArgList)->end(); I != E; ++I) {
5348 const Type *Ty = I->first.PAT->get();
5349 ParamTyList.push_back(Ty);
5350 FTySign.add(I->first.S);
5354 bool isVarArg = ParamTyList.size() && ParamTyList.back() == Type::VoidTy;
5356 ParamTyList.pop_back();
5358 // Convert the CSRet calling convention into the corresponding parameter
5360 FunctionType::ParamAttrsList ParamAttrs;
5361 if ((yyvsp[-7].UIntVal) == OldCallingConv::CSRet) {
5362 ParamAttrs.push_back(FunctionType::NoAttributeSet); // result
5363 ParamAttrs.push_back(FunctionType::StructRetAttribute); // first arg
5366 const FunctionType *FT = FunctionType::get(RetTy, ParamTyList, isVarArg,
5368 const PointerType *PFT = PointerType::get(FT);
5369 delete (yyvsp[-6].TypeVal).PAT;
5372 if (!FunctionName.empty()) {
5373 ID = ValID::create((char*)FunctionName.c_str());
5375 ID = ValID::create((int)CurModule.Values[PFT].size());
5377 ID.S.makeComposite(FTySign);
5380 Module* M = CurModule.CurrentModule;
5382 // See if this function was forward referenced. If so, recycle the object.
5383 if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
5384 // Move the function to the end of the list, from whereever it was
5385 // previously inserted.
5386 Fn = cast<Function>(FWRef);
5387 M->getFunctionList().remove(Fn);
5388 M->getFunctionList().push_back(Fn);
5389 } else if (!FunctionName.empty()) {
5390 GlobalValue *Conflict = M->getFunction(FunctionName);
5392 Conflict = M->getNamedGlobal(FunctionName);
5393 if (Conflict && PFT == Conflict->getType()) {
5394 if (!CurFun.isDeclare && !Conflict->isDeclaration()) {
5395 // We have two function definitions that conflict, same type, same
5396 // name. We should really check to make sure that this is the result
5397 // of integer type planes collapsing and generate an error if it is
5398 // not, but we'll just rename on the assumption that it is. However,
5399 // let's do it intelligently and rename the internal linkage one
5401 std::string NewName(makeNameUnique(FunctionName));
5402 if (Conflict->hasInternalLinkage()) {
5403 Conflict->setName(NewName);
5405 makeRenameMapKey(FunctionName, Conflict->getType(), ID.S);
5406 CurModule.RenameMap[Key] = NewName;
5407 Fn = new Function(FT, CurFun.Linkage, FunctionName, M);
5408 InsertValue(Fn, CurModule.Values);
5410 Fn = new Function(FT, CurFun.Linkage, NewName, M);
5411 InsertValue(Fn, CurModule.Values);
5413 makeRenameMapKey(FunctionName, PFT, ID.S);
5414 CurModule.RenameMap[Key] = NewName;
5417 // If they are not both definitions, then just use the function we
5418 // found since the types are the same.
5419 Fn = cast<Function>(Conflict);
5421 // Make sure to strip off any argument names so we can't get
5423 if (Fn->isDeclaration())
5424 for (Function::arg_iterator AI = Fn->arg_begin(),
5425 AE = Fn->arg_end(); AI != AE; ++AI)
5428 } else if (Conflict) {
5429 // We have two globals with the same name and different types.
5430 // Previously, this was permitted because the symbol table had
5431 // "type planes" and names only needed to be distinct within a
5432 // type plane. After PR411 was fixed, this is no loner the case.
5433 // To resolve this we must rename one of the two.
5434 if (Conflict->hasInternalLinkage()) {
5435 // We can safely rename the Conflict.
5437 makeRenameMapKey(Conflict->getName(), Conflict->getType(),
5438 CurModule.NamedValueSigns[Conflict->getName()]);
5439 Conflict->setName(makeNameUnique(Conflict->getName()));
5440 CurModule.RenameMap[Key] = Conflict->getName();
5441 Fn = new Function(FT, CurFun.Linkage, FunctionName, M);
5442 InsertValue(Fn, CurModule.Values);
5444 // We can't quietly rename either of these things, but we must
5445 // rename one of them. Only if the function's linkage is internal can
5446 // we forgo a warning message about the renamed function.
5447 std::string NewName = makeNameUnique(FunctionName);
5448 if (CurFun.Linkage != GlobalValue::InternalLinkage) {
5449 warning("Renaming function '" + FunctionName + "' as '" + NewName +
5450 "' may cause linkage errors");
5452 // Elect to rename the thing we're now defining.
5453 Fn = new Function(FT, CurFun.Linkage, NewName, M);
5454 InsertValue(Fn, CurModule.Values);
5455 RenameMapKey Key = makeRenameMapKey(FunctionName, PFT, ID.S);
5456 CurModule.RenameMap[Key] = NewName;
5459 // There's no conflict, just define the function
5460 Fn = new Function(FT, CurFun.Linkage, FunctionName, M);
5461 InsertValue(Fn, CurModule.Values);
5465 CurFun.FunctionStart(Fn);
5467 if (CurFun.isDeclare) {
5468 // If we have declaration, always overwrite linkage. This will allow us
5469 // to correctly handle cases, when pointer to function is passed as
5470 // argument to another function.
5471 Fn->setLinkage(CurFun.Linkage);
5473 Fn->setCallingConv(upgradeCallingConv((yyvsp[-7].UIntVal)));
5474 Fn->setAlignment((yyvsp[0].UIntVal));
5475 if ((yyvsp[-1].StrVal)) {
5476 Fn->setSection((yyvsp[-1].StrVal));
5477 free((yyvsp[-1].StrVal));
5480 // Add all of the arguments we parsed to the function...
5481 if ((yyvsp[-3].ArgList)) { // Is null if empty...
5482 if (isVarArg) { // Nuke the last entry
5483 assert((yyvsp[-3].ArgList)->back().first.PAT->get() == Type::VoidTy &&
5484 (yyvsp[-3].ArgList)->back().second == 0 && "Not a varargs marker");
5485 delete (yyvsp[-3].ArgList)->back().first.PAT;
5486 (yyvsp[-3].ArgList)->pop_back(); // Delete the last entry
5488 Function::arg_iterator ArgIt = Fn->arg_begin();
5489 Function::arg_iterator ArgEnd = Fn->arg_end();
5490 std::vector<std::pair<PATypeInfo,char*> >::iterator I = (yyvsp[-3].ArgList)->begin();
5491 std::vector<std::pair<PATypeInfo,char*> >::iterator E = (yyvsp[-3].ArgList)->end();
5492 for ( ; I != E && ArgIt != ArgEnd; ++I, ++ArgIt) {
5493 delete I->first.PAT; // Delete the typeholder...
5494 ValueInfo VI; VI.V = ArgIt; VI.S.copy(I->first.S);
5495 setValueName(VI, I->second); // Insert arg into symtab...
5498 delete (yyvsp[-3].ArgList); // We're now done with the argument list
5504 #line 3023 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5505 { CurFun.Linkage = (yyvsp[0].Linkage); ;}
5509 #line 3023 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5511 (yyval.FunctionVal) = CurFun.CurrentFunction;
5513 // Make sure that we keep track of the linkage type even if there was a
5514 // previous "declare".
5515 (yyval.FunctionVal)->setLinkage((yyvsp[-3].Linkage));
5520 #line 3037 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5522 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5527 #line 3042 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5528 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
5532 #line 3043 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5533 { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
5537 #line 3044 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5538 { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
5542 #line 3048 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5543 { CurFun.isDeclare = true; ;}
5547 #line 3049 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5548 { CurFun.Linkage = (yyvsp[0].Linkage); ;}
5552 #line 3049 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5554 (yyval.FunctionVal) = CurFun.CurrentFunction;
5555 CurFun.FunctionDone();
5561 #line 3061 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5562 { (yyval.BoolVal) = false; ;}
5566 #line 3062 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5567 { (yyval.BoolVal) = true; ;}
5571 #line 3067 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5572 { (yyval.ValIDVal) = ValID::create((yyvsp[0].SInt64Val)); ;}
5576 #line 3068 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5577 { (yyval.ValIDVal) = ValID::create((yyvsp[0].UInt64Val)); ;}
5581 #line 3069 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5582 { (yyval.ValIDVal) = ValID::create((yyvsp[0].FPVal)); ;}
5586 #line 3070 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5588 (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, true));
5589 (yyval.ValIDVal).S.makeUnsigned();
5594 #line 3074 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5596 (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, false));
5597 (yyval.ValIDVal).S.makeUnsigned();
5602 #line 3078 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5603 { (yyval.ValIDVal) = ValID::createNull(); ;}
5607 #line 3079 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5608 { (yyval.ValIDVal) = ValID::createUndef(); ;}
5612 #line 3080 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5613 { (yyval.ValIDVal) = ValID::createZeroInit(); ;}
5617 #line 3081 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5618 { // Nonempty unsized packed vector
5619 const Type *ETy = (*(yyvsp[-1].ConstVector))[0].C->getType();
5620 int NumElements = (yyvsp[-1].ConstVector)->size();
5621 VectorType* pt = VectorType::get(ETy, NumElements);
5622 (yyval.ValIDVal).S.makeComposite((*(yyvsp[-1].ConstVector))[0].S);
5623 PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(pt, (yyval.ValIDVal).S));
5625 // Verify all elements are correct type!
5626 std::vector<Constant*> Elems;
5627 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
5628 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
5629 const Type *CTy = C->getType();
5631 error("Element #" + utostr(i) + " is not of type '" +
5632 ETy->getDescription() +"' as required!\nIt is of type '" +
5633 CTy->getDescription() + "'");
5636 (yyval.ValIDVal) = ValID::create(ConstantVector::get(pt, Elems));
5637 delete PTy; delete (yyvsp[-1].ConstVector);
5642 #line 3102 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5644 (yyval.ValIDVal) = ValID::create((yyvsp[0].ConstVal).C);
5645 (yyval.ValIDVal).S.copy((yyvsp[0].ConstVal).S);
5650 #line 3106 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5652 char *End = UnEscapeLexed((yyvsp[-2].StrVal), true);
5653 std::string AsmStr = std::string((yyvsp[-2].StrVal), End);
5654 End = UnEscapeLexed((yyvsp[0].StrVal), true);
5655 std::string Constraints = std::string((yyvsp[0].StrVal), End);
5656 (yyval.ValIDVal) = ValID::createInlineAsm(AsmStr, Constraints, (yyvsp[-3].BoolVal));
5657 free((yyvsp[-2].StrVal));
5658 free((yyvsp[0].StrVal));
5663 #line 3120 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5664 { (yyval.ValIDVal) = ValID::create((yyvsp[0].SIntVal)); (yyval.ValIDVal).S.makeSignless(); ;}
5668 #line 3121 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5669 { (yyval.ValIDVal) = ValID::create((yyvsp[0].StrVal)); (yyval.ValIDVal).S.makeSignless(); ;}
5673 #line 3134 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5675 const Type *Ty = (yyvsp[-1].TypeVal).PAT->get();
5676 (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S);
5677 (yyval.ValueVal).V = getVal(Ty, (yyvsp[0].ValIDVal));
5678 (yyval.ValueVal).S.copy((yyvsp[-1].TypeVal).S);
5679 delete (yyvsp[-1].TypeVal).PAT;
5684 #line 3144 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5686 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5691 #line 3147 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5692 { // Do not allow functions with 0 basic blocks
5693 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5698 #line 3156 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5700 ValueInfo VI; VI.V = (yyvsp[0].TermInstVal).TI; VI.S.copy((yyvsp[0].TermInstVal).S);
5701 setValueName(VI, (yyvsp[-1].StrVal));
5702 InsertValue((yyvsp[0].TermInstVal).TI);
5703 (yyvsp[-2].BasicBlockVal)->getInstList().push_back((yyvsp[0].TermInstVal).TI);
5704 InsertValue((yyvsp[-2].BasicBlockVal));
5705 (yyval.BasicBlockVal) = (yyvsp[-2].BasicBlockVal);
5710 #line 3167 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5712 if ((yyvsp[0].InstVal).I)
5713 (yyvsp[-1].BasicBlockVal)->getInstList().push_back((yyvsp[0].InstVal).I);
5714 (yyval.BasicBlockVal) = (yyvsp[-1].BasicBlockVal);
5719 #line 3172 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5721 (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++),true);
5722 // Make sure to move the basic block to the correct location in the
5723 // function, instead of leaving it inserted wherever it was first
5725 Function::BasicBlockListType &BBL =
5726 CurFun.CurrentFunction->getBasicBlockList();
5727 BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
5732 #line 3181 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5734 (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((yyvsp[0].StrVal)), true);
5735 // Make sure to move the basic block to the correct location in the
5736 // function, instead of leaving it inserted wherever it was first
5738 Function::BasicBlockListType &BBL =
5739 CurFun.CurrentFunction->getBasicBlockList();
5740 BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
5745 #line 3195 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5746 { // Return with a result...
5747 (yyval.TermInstVal).TI = new ReturnInst((yyvsp[0].ValueVal).V);
5748 (yyval.TermInstVal).S.makeSignless();
5753 #line 3199 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5754 { // Return with no result...
5755 (yyval.TermInstVal).TI = new ReturnInst();
5756 (yyval.TermInstVal).S.makeSignless();
5761 #line 3203 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5762 { // Unconditional Branch...
5763 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5764 (yyval.TermInstVal).TI = new BranchInst(tmpBB);
5765 (yyval.TermInstVal).S.makeSignless();
5770 #line 3208 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5772 (yyvsp[-3].ValIDVal).S.makeSignless();
5773 (yyvsp[0].ValIDVal).S.makeSignless();
5774 BasicBlock* tmpBBA = getBBVal((yyvsp[-3].ValIDVal));
5775 BasicBlock* tmpBBB = getBBVal((yyvsp[0].ValIDVal));
5776 (yyvsp[-6].ValIDVal).S.makeUnsigned();
5777 Value* tmpVal = getVal(Type::Int1Ty, (yyvsp[-6].ValIDVal));
5778 (yyval.TermInstVal).TI = new BranchInst(tmpBBA, tmpBBB, tmpVal);
5779 (yyval.TermInstVal).S.makeSignless();
5784 #line 3218 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5786 (yyvsp[-6].ValIDVal).S.copy((yyvsp[-7].PrimType).S);
5787 Value* tmpVal = getVal((yyvsp[-7].PrimType).T, (yyvsp[-6].ValIDVal));
5788 (yyvsp[-3].ValIDVal).S.makeSignless();
5789 BasicBlock* tmpBB = getBBVal((yyvsp[-3].ValIDVal));
5790 SwitchInst *S = new SwitchInst(tmpVal, tmpBB, (yyvsp[-1].JumpTable)->size());
5791 (yyval.TermInstVal).TI = S;
5792 (yyval.TermInstVal).S.makeSignless();
5793 std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = (yyvsp[-1].JumpTable)->begin(),
5794 E = (yyvsp[-1].JumpTable)->end();
5795 for (; I != E; ++I) {
5796 if (ConstantInt *CI = dyn_cast<ConstantInt>(I->first))
5797 S->addCase(CI, I->second);
5799 error("Switch case is constant, but not a simple integer");
5801 delete (yyvsp[-1].JumpTable);
5806 #line 3236 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5808 (yyvsp[-5].ValIDVal).S.copy((yyvsp[-6].PrimType).S);
5809 Value* tmpVal = getVal((yyvsp[-6].PrimType).T, (yyvsp[-5].ValIDVal));
5810 (yyvsp[-2].ValIDVal).S.makeSignless();
5811 BasicBlock* tmpBB = getBBVal((yyvsp[-2].ValIDVal));
5812 SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
5813 (yyval.TermInstVal).TI = S;
5814 (yyval.TermInstVal).S.makeSignless();
5819 #line 3246 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5821 const PointerType *PFTy;
5822 const FunctionType *Ty;
5825 if (!(PFTy = dyn_cast<PointerType>((yyvsp[-10].TypeVal).PAT->get())) ||
5826 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
5827 // Pull out the types of all of the arguments...
5828 std::vector<const Type*> ParamTypes;
5829 FTySign.makeComposite((yyvsp[-10].TypeVal).S);
5830 if ((yyvsp[-7].ValueList)) {
5831 for (std::vector<ValueInfo>::iterator I = (yyvsp[-7].ValueList)->begin(), E = (yyvsp[-7].ValueList)->end();
5833 ParamTypes.push_back((*I).V->getType());
5837 FunctionType::ParamAttrsList ParamAttrs;
5838 if ((yyvsp[-11].UIntVal) == OldCallingConv::CSRet) {
5839 ParamAttrs.push_back(FunctionType::NoAttributeSet);
5840 ParamAttrs.push_back(FunctionType::StructRetAttribute);
5842 bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
5843 if (isVarArg) ParamTypes.pop_back();
5844 Ty = FunctionType::get((yyvsp[-10].TypeVal).PAT->get(), ParamTypes, isVarArg, ParamAttrs);
5845 PFTy = PointerType::get(Ty);
5846 (yyval.TermInstVal).S.copy((yyvsp[-10].TypeVal).S);
5848 FTySign = (yyvsp[-10].TypeVal).S;
5849 (yyval.TermInstVal).S.copy((yyvsp[-10].TypeVal).S.get(0)); // 0th element of FuncTy sign is result ty
5851 (yyvsp[-9].ValIDVal).S.makeComposite(FTySign);
5852 Value *V = getVal(PFTy, (yyvsp[-9].ValIDVal)); // Get the function we're calling...
5853 BasicBlock *Normal = getBBVal((yyvsp[-3].ValIDVal));
5854 BasicBlock *Except = getBBVal((yyvsp[0].ValIDVal));
5856 // Create the call node...
5857 if (!(yyvsp[-7].ValueList)) { // Has no arguments?
5858 (yyval.TermInstVal).TI = new InvokeInst(V, Normal, Except, 0, 0);
5859 } else { // Has arguments?
5860 // Loop through FunctionType's arguments and ensure they are specified
5863 FunctionType::param_iterator I = Ty->param_begin();
5864 FunctionType::param_iterator E = Ty->param_end();
5865 std::vector<ValueInfo>::iterator ArgI = (yyvsp[-7].ValueList)->begin(), ArgE = (yyvsp[-7].ValueList)->end();
5867 std::vector<Value*> Args;
5868 for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
5869 if ((*ArgI).V->getType() != *I)
5870 error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
5871 (*I)->getDescription() + "'");
5872 Args.push_back((*ArgI).V);
5875 if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
5876 error("Invalid number of parameters detected");
5878 (yyval.TermInstVal).TI = new InvokeInst(V, Normal, Except, &Args[0], Args.size());
5880 cast<InvokeInst>((yyval.TermInstVal).TI)->setCallingConv(upgradeCallingConv((yyvsp[-11].UIntVal)));
5881 delete (yyvsp[-10].TypeVal).PAT;
5882 delete (yyvsp[-7].ValueList);
5887 #line 3310 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5889 (yyval.TermInstVal).TI = new UnwindInst();
5890 (yyval.TermInstVal).S.makeSignless();
5895 #line 3314 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5897 (yyval.TermInstVal).TI = new UnreachableInst();
5898 (yyval.TermInstVal).S.makeSignless();
5903 #line 3321 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5905 (yyval.JumpTable) = (yyvsp[-5].JumpTable);
5906 (yyvsp[-3].ValIDVal).S.copy((yyvsp[-4].PrimType).S);
5907 Constant *V = cast<Constant>(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal)));
5910 error("May only switch on a constant pool value");
5912 (yyvsp[0].ValIDVal).S.makeSignless();
5913 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5914 (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
5919 #line 3333 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5921 (yyval.JumpTable) = new std::vector<std::pair<Constant*, BasicBlock*> >();
5922 (yyvsp[-3].ValIDVal).S.copy((yyvsp[-4].PrimType).S);
5923 Constant *V = cast<Constant>(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal)));
5926 error("May only switch on a constant pool value");
5928 (yyvsp[0].ValIDVal).S.makeSignless();
5929 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5930 (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
5935 #line 3348 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5938 if ((yyvsp[-1].StrVal))
5939 if (BitCastInst *BCI = dyn_cast<BitCastInst>((yyvsp[0].InstVal).I))
5940 if (BCI->getSrcTy() == BCI->getDestTy() &&
5941 BCI->getOperand(0)->getName() == (yyvsp[-1].StrVal))
5942 // This is a useless bit cast causing a name redefinition. It is
5943 // a bit cast from a type to the same type of an operand with the
5944 // same name as the name we would give this instruction. Since this
5945 // instruction results in no code generation, it is safe to omit
5946 // the instruction. This situation can occur because of collapsed
5947 // type planes. For example:
5948 // %X = add int %Y, %Z
5949 // %X = cast int %Y to uint
5950 // After upgrade, this looks like:
5951 // %X = add i32 %Y, %Z
5952 // %X = bitcast i32 to i32
5953 // The bitcast is clearly useless so we omit it.
5956 (yyval.InstVal).I = 0;
5957 (yyval.InstVal).S.makeSignless();
5959 ValueInfo VI; VI.V = (yyvsp[0].InstVal).I; VI.S.copy((yyvsp[0].InstVal).S);
5960 setValueName(VI, (yyvsp[-1].StrVal));
5961 InsertValue((yyvsp[0].InstVal).I);
5962 (yyval.InstVal) = (yyvsp[0].InstVal);
5968 #line 3378 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5969 { // Used for PHI nodes
5970 (yyval.PHIList).P = new std::list<std::pair<Value*, BasicBlock*> >();
5971 (yyval.PHIList).S.copy((yyvsp[-5].TypeVal).S);
5972 (yyvsp[-3].ValIDVal).S.copy((yyvsp[-5].TypeVal).S);
5973 Value* tmpVal = getVal((yyvsp[-5].TypeVal).PAT->get(), (yyvsp[-3].ValIDVal));
5974 (yyvsp[-1].ValIDVal).S.makeSignless();
5975 BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
5976 (yyval.PHIList).P->push_back(std::make_pair(tmpVal, tmpBB));
5977 delete (yyvsp[-5].TypeVal).PAT;
5982 #line 3388 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5984 (yyval.PHIList) = (yyvsp[-6].PHIList);
5985 (yyvsp[-3].ValIDVal).S.copy((yyvsp[-6].PHIList).S);
5986 Value* tmpVal = getVal((yyvsp[-6].PHIList).P->front().first->getType(), (yyvsp[-3].ValIDVal));
5987 (yyvsp[-1].ValIDVal).S.makeSignless();
5988 BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
5989 (yyvsp[-6].PHIList).P->push_back(std::make_pair(tmpVal, tmpBB));
5994 #line 3398 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5995 { // Used for call statements, and memory insts...
5996 (yyval.ValueList) = new std::vector<ValueInfo>();
5997 (yyval.ValueList)->push_back((yyvsp[0].ValueVal));
6002 #line 3402 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6004 (yyval.ValueList) = (yyvsp[-2].ValueList);
6005 (yyvsp[-2].ValueList)->push_back((yyvsp[0].ValueVal));
6010 #line 3410 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6011 { (yyval.ValueList) = 0; ;}
6015 #line 3414 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6017 (yyval.BoolVal) = true;
6022 #line 3417 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6024 (yyval.BoolVal) = false;
6029 #line 3423 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6031 (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6032 (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6033 const Type* Ty = (yyvsp[-3].TypeVal).PAT->get();
6034 if (!Ty->isInteger() && !Ty->isFloatingPoint() && !isa<VectorType>(Ty))
6035 error("Arithmetic operator requires integer, FP, or packed operands");
6036 if (isa<VectorType>(Ty) &&
6037 ((yyvsp[-4].BinaryOpVal) == URemOp || (yyvsp[-4].BinaryOpVal) == SRemOp || (yyvsp[-4].BinaryOpVal) == FRemOp || (yyvsp[-4].BinaryOpVal) == RemOp))
6038 error("Remainder not supported on vector types");
6039 // Upgrade the opcode from obsolete versions before we do anything with it.
6040 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S);
6041 Value* val1 = getVal(Ty, (yyvsp[-2].ValIDVal));
6042 Value* val2 = getVal(Ty, (yyvsp[0].ValIDVal));
6043 (yyval.InstVal).I = BinaryOperator::create(Opcode, val1, val2);
6044 if ((yyval.InstVal).I == 0)
6045 error("binary operator returned null");
6046 (yyval.InstVal).S.copy((yyvsp[-3].TypeVal).S);
6047 delete (yyvsp[-3].TypeVal).PAT;
6052 #line 3442 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6054 (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6055 (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6056 const Type *Ty = (yyvsp[-3].TypeVal).PAT->get();
6057 if (!Ty->isInteger()) {
6058 if (!isa<VectorType>(Ty) ||
6059 !cast<VectorType>(Ty)->getElementType()->isInteger())
6060 error("Logical operator requires integral operands");
6062 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S);
6063 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
6064 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
6065 (yyval.InstVal).I = BinaryOperator::create(Opcode, tmpVal1, tmpVal2);
6066 if ((yyval.InstVal).I == 0)
6067 error("binary operator returned null");
6068 (yyval.InstVal).S.copy((yyvsp[-3].TypeVal).S);
6069 delete (yyvsp[-3].TypeVal).PAT;
6074 #line 3460 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6076 (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6077 (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6078 const Type* Ty = (yyvsp[-3].TypeVal).PAT->get();
6079 if(isa<VectorType>(Ty))
6080 error("VectorTypes currently not supported in setcc instructions");
6081 unsigned short pred;
6082 Instruction::OtherOps Opcode = getCompareOp((yyvsp[-4].BinaryOpVal), pred, Ty, (yyvsp[-3].TypeVal).S);
6083 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
6084 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
6085 (yyval.InstVal).I = CmpInst::create(Opcode, pred, tmpVal1, tmpVal2);
6086 if ((yyval.InstVal).I == 0)
6087 error("binary operator returned null");
6088 (yyval.InstVal).S.makeUnsigned();
6089 delete (yyvsp[-3].TypeVal).PAT;
6094 #line 3476 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6096 (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6097 (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6098 const Type *Ty = (yyvsp[-3].TypeVal).PAT->get();
6099 if (isa<VectorType>(Ty))
6100 error("VectorTypes currently not supported in icmp instructions");
6101 else if (!Ty->isInteger() && !isa<PointerType>(Ty))
6102 error("icmp requires integer or pointer typed operands");
6103 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
6104 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
6105 (yyval.InstVal).I = new ICmpInst((yyvsp[-4].IPred), tmpVal1, tmpVal2);
6106 (yyval.InstVal).S.makeUnsigned();
6107 delete (yyvsp[-3].TypeVal).PAT;
6112 #line 3490 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6114 (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6115 (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6116 const Type *Ty = (yyvsp[-3].TypeVal).PAT->get();
6117 if (isa<VectorType>(Ty))
6118 error("VectorTypes currently not supported in fcmp instructions");
6119 else if (!Ty->isFloatingPoint())
6120 error("fcmp instruction requires floating point operands");
6121 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
6122 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
6123 (yyval.InstVal).I = new FCmpInst((yyvsp[-4].FPred), tmpVal1, tmpVal2);
6124 (yyval.InstVal).S.makeUnsigned();
6125 delete (yyvsp[-3].TypeVal).PAT;
6130 #line 3504 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6132 warning("Use of obsolete 'not' instruction: Replacing with 'xor");
6133 const Type *Ty = (yyvsp[0].ValueVal).V->getType();
6134 Value *Ones = ConstantInt::getAllOnesValue(Ty);
6136 error("Expected integral type for not instruction");
6137 (yyval.InstVal).I = BinaryOperator::create(Instruction::Xor, (yyvsp[0].ValueVal).V, Ones);
6138 if ((yyval.InstVal).I == 0)
6139 error("Could not create a xor instruction");
6140 (yyval.InstVal).S.copy((yyvsp[0].ValueVal).S);
6145 #line 3515 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6147 if (!(yyvsp[0].ValueVal).V->getType()->isInteger() ||
6148 cast<IntegerType>((yyvsp[0].ValueVal).V->getType())->getBitWidth() != 8)
6149 error("Shift amount must be int8");
6150 const Type* Ty = (yyvsp[-2].ValueVal).V->getType();
6151 if (!Ty->isInteger())
6152 error("Shift constant expression requires integer operand");
6153 Value* ShiftAmt = 0;
6154 if (cast<IntegerType>(Ty)->getBitWidth() > Type::Int8Ty->getBitWidth())
6155 if (Constant *C = dyn_cast<Constant>((yyvsp[0].ValueVal).V))
6156 ShiftAmt = ConstantExpr::getZExt(C, Ty);
6158 ShiftAmt = new ZExtInst((yyvsp[0].ValueVal).V, Ty, makeNameUnique("shift"), CurBB);
6160 ShiftAmt = (yyvsp[0].ValueVal).V;
6161 (yyval.InstVal).I = BinaryOperator::create(getBinaryOp((yyvsp[-3].BinaryOpVal), Ty, (yyvsp[-2].ValueVal).S), (yyvsp[-2].ValueVal).V, ShiftAmt);
6162 (yyval.InstVal).S.copy((yyvsp[-2].ValueVal).S);
6167 #line 3533 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6169 const Type *DstTy = (yyvsp[0].TypeVal).PAT->get();
6170 if (!DstTy->isFirstClassType())
6171 error("cast instruction to a non-primitive type: '" +
6172 DstTy->getDescription() + "'");
6173 (yyval.InstVal).I = cast<Instruction>(getCast((yyvsp[-3].CastOpVal), (yyvsp[-2].ValueVal).V, (yyvsp[-2].ValueVal).S, DstTy, (yyvsp[0].TypeVal).S, true));
6174 (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S);
6175 delete (yyvsp[0].TypeVal).PAT;
6180 #line 3542 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6182 if (!(yyvsp[-4].ValueVal).V->getType()->isInteger() ||
6183 cast<IntegerType>((yyvsp[-4].ValueVal).V->getType())->getBitWidth() != 1)
6184 error("select condition must be bool");
6185 if ((yyvsp[-2].ValueVal).V->getType() != (yyvsp[0].ValueVal).V->getType())
6186 error("select value types should match");
6187 (yyval.InstVal).I = new SelectInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
6188 (yyval.InstVal).S.copy((yyvsp[-2].ValueVal).S);
6193 #line 3551 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6195 const Type *Ty = (yyvsp[0].TypeVal).PAT->get();
6197 (yyval.InstVal).I = new VAArgInst((yyvsp[-2].ValueVal).V, Ty);
6198 (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S);
6199 delete (yyvsp[0].TypeVal).PAT;
6204 #line 3558 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6206 const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType();
6207 const Type* DstTy = (yyvsp[0].TypeVal).PAT->get();
6208 ObsoleteVarArgs = true;
6209 Function* NF = cast<Function>(CurModule.CurrentModule->
6210 getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
6213 //foo = alloca 1 of t
6217 AllocaInst* foo = new AllocaInst(ArgTy, 0, "vaarg.fix");
6218 CurBB->getInstList().push_back(foo);
6219 CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V);
6220 CurBB->getInstList().push_back(bar);
6221 CurBB->getInstList().push_back(new StoreInst(bar, foo));
6222 (yyval.InstVal).I = new VAArgInst(foo, DstTy);
6223 (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S);
6224 delete (yyvsp[0].TypeVal).PAT;
6229 #line 3579 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6231 const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType();
6232 const Type* DstTy = (yyvsp[0].TypeVal).PAT->get();
6233 ObsoleteVarArgs = true;
6234 Function* NF = cast<Function>(CurModule.CurrentModule->
6235 getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
6237 //b = vanext a, t ->
6238 //foo = alloca 1 of t
6241 //tmp = vaarg foo, t
6243 AllocaInst* foo = new AllocaInst(ArgTy, 0, "vanext.fix");
6244 CurBB->getInstList().push_back(foo);
6245 CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V);
6246 CurBB->getInstList().push_back(bar);
6247 CurBB->getInstList().push_back(new StoreInst(bar, foo));
6248 Instruction* tmp = new VAArgInst(foo, DstTy);
6249 CurBB->getInstList().push_back(tmp);
6250 (yyval.InstVal).I = new LoadInst(foo);
6251 (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S);
6252 delete (yyvsp[0].TypeVal).PAT;
6257 #line 3603 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6259 if (!ExtractElementInst::isValidOperands((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
6260 error("Invalid extractelement operands");
6261 (yyval.InstVal).I = new ExtractElementInst((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
6262 (yyval.InstVal).S.copy((yyvsp[-2].ValueVal).S.get(0));
6267 #line 3609 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6269 if (!InsertElementInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
6270 error("Invalid insertelement operands");
6271 (yyval.InstVal).I = new InsertElementInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
6272 (yyval.InstVal).S.copy((yyvsp[-4].ValueVal).S);
6277 #line 3615 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6279 if (!ShuffleVectorInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
6280 error("Invalid shufflevector operands");
6281 (yyval.InstVal).I = new ShuffleVectorInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
6282 (yyval.InstVal).S.copy((yyvsp[-4].ValueVal).S);
6287 #line 3621 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6289 const Type *Ty = (yyvsp[0].PHIList).P->front().first->getType();
6290 if (!Ty->isFirstClassType())
6291 error("PHI node operands must be of first class type");
6292 PHINode *PHI = new PHINode(Ty);
6293 PHI->reserveOperandSpace((yyvsp[0].PHIList).P->size());
6294 while ((yyvsp[0].PHIList).P->begin() != (yyvsp[0].PHIList).P->end()) {
6295 if ((yyvsp[0].PHIList).P->front().first->getType() != Ty)
6296 error("All elements of a PHI node must be of the same type");
6297 PHI->addIncoming((yyvsp[0].PHIList).P->front().first, (yyvsp[0].PHIList).P->front().second);
6298 (yyvsp[0].PHIList).P->pop_front();
6300 (yyval.InstVal).I = PHI;
6301 (yyval.InstVal).S.copy((yyvsp[0].PHIList).S);
6302 delete (yyvsp[0].PHIList).P; // Free the list...
6307 #line 3637 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6309 // Handle the short call syntax
6310 const PointerType *PFTy;
6311 const FunctionType *FTy;
6313 if (!(PFTy = dyn_cast<PointerType>((yyvsp[-4].TypeVal).PAT->get())) ||
6314 !(FTy = dyn_cast<FunctionType>(PFTy->getElementType()))) {
6315 // Pull out the types of all of the arguments...
6316 std::vector<const Type*> ParamTypes;
6317 FTySign.makeComposite((yyvsp[-4].TypeVal).S);
6318 if ((yyvsp[-1].ValueList)) {
6319 for (std::vector<ValueInfo>::iterator I = (yyvsp[-1].ValueList)->begin(), E = (yyvsp[-1].ValueList)->end();
6321 ParamTypes.push_back((*I).V->getType());
6326 FunctionType::ParamAttrsList ParamAttrs;
6327 if ((yyvsp[-5].UIntVal) == OldCallingConv::CSRet) {
6328 ParamAttrs.push_back(FunctionType::NoAttributeSet);
6329 ParamAttrs.push_back(FunctionType::StructRetAttribute);
6331 bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
6332 if (isVarArg) ParamTypes.pop_back();
6334 const Type *RetTy = (yyvsp[-4].TypeVal).PAT->get();
6335 if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
6336 error("Functions cannot return aggregate types");
6338 FTy = FunctionType::get(RetTy, ParamTypes, isVarArg, ParamAttrs);
6339 PFTy = PointerType::get(FTy);
6340 (yyval.InstVal).S.copy((yyvsp[-4].TypeVal).S);
6342 FTySign = (yyvsp[-4].TypeVal).S;
6343 (yyval.InstVal).S.copy((yyvsp[-4].TypeVal).S.get(0)); // 0th element of FuncTy signedness is result sign
6345 (yyvsp[-3].ValIDVal).S.makeComposite(FTySign);
6347 // First upgrade any intrinsic calls.
6348 std::vector<Value*> Args;
6349 if ((yyvsp[-1].ValueList))
6350 for (unsigned i = 0, e = (yyvsp[-1].ValueList)->size(); i < e; ++i)
6351 Args.push_back((*(yyvsp[-1].ValueList))[i].V);
6352 Instruction *Inst = upgradeIntrinsicCall(FTy->getReturnType(), (yyvsp[-3].ValIDVal), Args);
6354 // If we got an upgraded intrinsic
6356 (yyval.InstVal).I = Inst;
6358 // Get the function we're calling
6359 Value *V = getVal(PFTy, (yyvsp[-3].ValIDVal));
6361 // Check the argument values match
6362 if (!(yyvsp[-1].ValueList)) { // Has no arguments?
6363 // Make sure no arguments is a good thing!
6364 if (FTy->getNumParams() != 0)
6365 error("No arguments passed to a function that expects arguments");
6366 } else { // Has arguments?
6367 // Loop through FunctionType's arguments and ensure they are specified
6370 FunctionType::param_iterator I = FTy->param_begin();
6371 FunctionType::param_iterator E = FTy->param_end();
6372 std::vector<ValueInfo>::iterator ArgI = (yyvsp[-1].ValueList)->begin(), ArgE = (yyvsp[-1].ValueList)->end();
6374 for (; ArgI != ArgE && I != E; ++ArgI, ++I)
6375 if ((*ArgI).V->getType() != *I)
6376 error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
6377 (*I)->getDescription() + "'");
6379 if (I != E || (ArgI != ArgE && !FTy->isVarArg()))
6380 error("Invalid number of parameters detected");
6383 // Create the call instruction
6384 CallInst *CI = new CallInst(V, &Args[0], Args.size());
6385 CI->setTailCall((yyvsp[-6].BoolVal));
6386 CI->setCallingConv(upgradeCallingConv((yyvsp[-5].UIntVal)));
6387 (yyval.InstVal).I = CI;
6389 delete (yyvsp[-4].TypeVal).PAT;
6390 delete (yyvsp[-1].ValueList);
6395 #line 3721 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6397 (yyval.InstVal) = (yyvsp[0].InstVal);
6402 #line 3729 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6403 { (yyval.ValueList) = (yyvsp[0].ValueList); ;}
6407 #line 3730 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6408 { (yyval.ValueList) = new std::vector<ValueInfo>(); ;}
6412 #line 3734 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6413 { (yyval.BoolVal) = true; ;}
6417 #line 3735 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6418 { (yyval.BoolVal) = false; ;}
6422 #line 3739 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6424 const Type *Ty = (yyvsp[-1].TypeVal).PAT->get();
6425 (yyval.InstVal).S.makeComposite((yyvsp[-1].TypeVal).S);
6426 (yyval.InstVal).I = new MallocInst(Ty, 0, (yyvsp[0].UIntVal));
6427 delete (yyvsp[-1].TypeVal).PAT;
6432 #line 3745 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6434 const Type *Ty = (yyvsp[-4].TypeVal).PAT->get();
6435 (yyvsp[-1].ValIDVal).S.makeUnsigned();
6436 (yyval.InstVal).S.makeComposite((yyvsp[-4].TypeVal).S);
6437 (yyval.InstVal).I = new MallocInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal));
6438 delete (yyvsp[-4].TypeVal).PAT;
6443 #line 3752 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6445 const Type *Ty = (yyvsp[-1].TypeVal).PAT->get();
6446 (yyval.InstVal).S.makeComposite((yyvsp[-1].TypeVal).S);
6447 (yyval.InstVal).I = new AllocaInst(Ty, 0, (yyvsp[0].UIntVal));
6448 delete (yyvsp[-1].TypeVal).PAT;
6453 #line 3758 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6455 const Type *Ty = (yyvsp[-4].TypeVal).PAT->get();
6456 (yyvsp[-1].ValIDVal).S.makeUnsigned();
6457 (yyval.InstVal).S.makeComposite((yyvsp[-2].PrimType).S);
6458 (yyval.InstVal).I = new AllocaInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal));
6459 delete (yyvsp[-4].TypeVal).PAT;
6464 #line 3765 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6466 const Type *PTy = (yyvsp[0].ValueVal).V->getType();
6467 if (!isa<PointerType>(PTy))
6468 error("Trying to free nonpointer type '" + PTy->getDescription() + "'");
6469 (yyval.InstVal).I = new FreeInst((yyvsp[0].ValueVal).V);
6470 (yyval.InstVal).S.makeSignless();
6475 #line 3772 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6477 const Type* Ty = (yyvsp[-1].TypeVal).PAT->get();
6478 (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S);
6479 if (!isa<PointerType>(Ty))
6480 error("Can't load from nonpointer type: " + Ty->getDescription());
6481 if (!cast<PointerType>(Ty)->getElementType()->isFirstClassType())
6482 error("Can't load from pointer of non-first-class type: " +
6483 Ty->getDescription());
6484 Value* tmpVal = getVal(Ty, (yyvsp[0].ValIDVal));
6485 (yyval.InstVal).I = new LoadInst(tmpVal, "", (yyvsp[-3].BoolVal));
6486 (yyval.InstVal).S.copy((yyvsp[-1].TypeVal).S.get(0));
6487 delete (yyvsp[-1].TypeVal).PAT;
6492 #line 3785 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6494 (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S);
6495 const PointerType *PTy = dyn_cast<PointerType>((yyvsp[-1].TypeVal).PAT->get());
6497 error("Can't store to a nonpointer type: " +
6498 (yyvsp[-1].TypeVal).PAT->get()->getDescription());
6499 const Type *ElTy = PTy->getElementType();
6500 Value *StoreVal = (yyvsp[-3].ValueVal).V;
6501 Value* tmpVal = getVal(PTy, (yyvsp[0].ValIDVal));
6502 if (ElTy != (yyvsp[-3].ValueVal).V->getType()) {
6503 StoreVal = handleSRetFuncTypeMerge((yyvsp[-3].ValueVal).V, ElTy);
6505 error("Can't store '" + (yyvsp[-3].ValueVal).V->getType()->getDescription() +
6506 "' into space of type '" + ElTy->getDescription() + "'");
6508 PTy = PointerType::get(StoreVal->getType());
6509 if (Constant *C = dyn_cast<Constant>(tmpVal))
6510 tmpVal = ConstantExpr::getBitCast(C, PTy);
6512 tmpVal = new BitCastInst(tmpVal, PTy, "upgrd.cast", CurBB);
6515 (yyval.InstVal).I = new StoreInst(StoreVal, tmpVal, (yyvsp[-5].BoolVal));
6516 (yyval.InstVal).S.makeSignless();
6517 delete (yyvsp[-1].TypeVal).PAT;
6522 #line 3811 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6524 (yyvsp[-1].ValIDVal).S.copy((yyvsp[-2].TypeVal).S);
6525 const Type* Ty = (yyvsp[-2].TypeVal).PAT->get();
6526 if (!isa<PointerType>(Ty))
6527 error("getelementptr insn requires pointer operand");
6529 std::vector<Value*> VIndices;
6530 upgradeGEPIndices(Ty, (yyvsp[0].ValueList), VIndices);
6532 Value* tmpVal = getVal(Ty, (yyvsp[-1].ValIDVal));
6533 (yyval.InstVal).I = new GetElementPtrInst(tmpVal, &VIndices[0], VIndices.size());
6534 ValueInfo VI; VI.V = tmpVal; VI.S.copy((yyvsp[-2].TypeVal).S);
6535 (yyval.InstVal).S.copy(getElementSign(VI, VIndices));
6536 delete (yyvsp[-2].TypeVal).PAT;
6537 delete (yyvsp[0].ValueList);
6545 /* Line 1126 of yacc.c. */
6546 #line 6547 "UpgradeParser.tab.c"
6552 YY_STACK_PRINT (yyss, yyssp);
6557 /* Now `shift' the result of the reduction. Determine what state
6558 that goes to, based on the state we popped back to and the rule
6559 number reduced by. */
6563 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
6564 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
6565 yystate = yytable[yystate];
6567 yystate = yydefgoto[yyn - YYNTOKENS];
6572 /*------------------------------------.
6573 | yyerrlab -- here on detecting error |
6574 `------------------------------------*/
6576 /* If not already recovering from an error, report this error. */
6581 yyn = yypact[yystate];
6583 if (YYPACT_NINF < yyn && yyn < YYLAST)
6585 int yytype = YYTRANSLATE (yychar);
6586 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
6587 YYSIZE_T yysize = yysize0;
6589 int yysize_overflow = 0;
6591 # define YYERROR_VERBOSE_ARGS_MAXIMUM 5
6592 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
6596 /* This is so xgettext sees the translatable formats that are
6597 constructed on the fly. */
6598 YY_("syntax error, unexpected %s");
6599 YY_("syntax error, unexpected %s, expecting %s");
6600 YY_("syntax error, unexpected %s, expecting %s or %s");
6601 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
6602 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
6606 static char const yyunexpected[] = "syntax error, unexpected %s";
6607 static char const yyexpecting[] = ", expecting %s";
6608 static char const yyor[] = " or %s";
6609 char yyformat[sizeof yyunexpected
6610 + sizeof yyexpecting - 1
6611 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
6612 * (sizeof yyor - 1))];
6613 char const *yyprefix = yyexpecting;
6615 /* Start YYX at -YYN if negative to avoid negative indexes in
6617 int yyxbegin = yyn < 0 ? -yyn : 0;
6619 /* Stay within bounds of both yycheck and yytname. */
6620 int yychecklim = YYLAST - yyn;
6621 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
6624 yyarg[0] = yytname[yytype];
6625 yyfmt = yystpcpy (yyformat, yyunexpected);
6627 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
6628 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
6630 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
6634 yyformat[sizeof yyunexpected - 1] = '\0';
6637 yyarg[yycount++] = yytname[yyx];
6638 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
6639 yysize_overflow |= yysize1 < yysize;
6641 yyfmt = yystpcpy (yyfmt, yyprefix);
6645 yyf = YY_(yyformat);
6646 yysize1 = yysize + yystrlen (yyf);
6647 yysize_overflow |= yysize1 < yysize;
6650 if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
6651 yymsg = (char *) YYSTACK_ALLOC (yysize);
6654 /* Avoid sprintf, as that infringes on the user's name space.
6655 Don't have undefined behavior even if the translation
6656 produced a string with the wrong number of "%s"s. */
6659 while ((*yyp = *yyf))
6661 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
6663 yyp += yytnamerr (yyp, yyarg[yyi++]);
6673 YYSTACK_FREE (yymsg);
6677 yyerror (YY_("syntax error"));
6678 goto yyexhaustedlab;
6682 #endif /* YYERROR_VERBOSE */
6683 yyerror (YY_("syntax error"));
6688 if (yyerrstatus == 3)
6690 /* If just tried and failed to reuse look-ahead token after an
6691 error, discard it. */
6693 if (yychar <= YYEOF)
6695 /* Return failure if at end of input. */
6696 if (yychar == YYEOF)
6701 yydestruct ("Error: discarding", yytoken, &yylval);
6706 /* Else will try to reuse look-ahead token after shifting the error
6711 /*---------------------------------------------------.
6712 | yyerrorlab -- error raised explicitly by YYERROR. |
6713 `---------------------------------------------------*/
6716 /* Pacify compilers like GCC when the user code never invokes
6717 YYERROR and the label yyerrorlab therefore never appears in user
6728 /*-------------------------------------------------------------.
6729 | yyerrlab1 -- common code for both syntax error and YYERROR. |
6730 `-------------------------------------------------------------*/
6732 yyerrstatus = 3; /* Each real token shifted decrements this. */
6736 yyn = yypact[yystate];
6737 if (yyn != YYPACT_NINF)
6740 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
6748 /* Pop the current state because it cannot handle the error token. */
6753 yydestruct ("Error: popping", yystos[yystate], yyvsp);
6756 YY_STACK_PRINT (yyss, yyssp);
6765 /* Shift the error token. */
6766 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
6772 /*-------------------------------------.
6773 | yyacceptlab -- YYACCEPT comes here. |
6774 `-------------------------------------*/
6779 /*-----------------------------------.
6780 | yyabortlab -- YYABORT comes here. |
6781 `-----------------------------------*/
6787 /*-------------------------------------------------.
6788 | yyexhaustedlab -- memory exhaustion comes here. |
6789 `-------------------------------------------------*/
6791 yyerror (YY_("memory exhausted"));
6797 if (yychar != YYEOF && yychar != YYEMPTY)
6798 yydestruct ("Cleanup: discarding lookahead",
6800 while (yyssp != yyss)
6802 yydestruct ("Cleanup: popping",
6803 yystos[*yyssp], yyvsp);
6808 YYSTACK_FREE (yyss);
6814 #line 3829 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6817 int yyerror(const char *ErrorMsg) {
6819 = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
6820 + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
6821 std::string errMsg = where + "error: " + std::string(ErrorMsg);
6822 if (yychar != YYEMPTY && yychar != 0)
6823 errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
6825 std::cerr << "llvm-upgrade: " << errMsg << '\n';
6826 std::cout << "llvm-upgrade: parse failed.\n";
6830 void warning(const std::string& ErrorMsg) {
6832 = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
6833 + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
6834 std::string errMsg = where + "warning: " + std::string(ErrorMsg);
6835 if (yychar != YYEMPTY && yychar != 0)
6836 errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
6838 std::cerr << "llvm-upgrade: " << errMsg << '\n';
6841 void error(const std::string& ErrorMsg, int LineNo) {
6842 if (LineNo == -1) LineNo = Upgradelineno;
6843 Upgradelineno = LineNo;
6844 yyerror(ErrorMsg.c_str());