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 : "";
1811 if (Name == "llvm.isunordered.f32" || Name == "llvm.isunordered.f64") {
1812 if (Args.size() != 2)
1813 error("Invalid prototype for " + Name + " prototype");
1814 return new FCmpInst(FCmpInst::FCMP_UNO, Args[0], Args[1]);
1816 const Type* PtrTy = PointerType::get(Type::Int8Ty);
1817 std::vector<const Type*> Params;
1818 if (Name == "llvm.va_start" || Name == "llvm.va_end") {
1819 if (Args.size() != 1)
1820 error("Invalid prototype for " + Name + " prototype");
1821 Params.push_back(PtrTy);
1822 const FunctionType *FTy = FunctionType::get(Type::VoidTy, Params, false);
1823 const PointerType *PFTy = PointerType::get(FTy);
1824 Value* Func = getVal(PFTy, ID);
1825 Args[0] = new BitCastInst(Args[0], PtrTy, makeNameUnique("va"), CurBB);
1826 return new CallInst(Func, &Args[0], Args.size());
1827 } else if (Name == "llvm.va_copy") {
1828 if (Args.size() != 2)
1829 error("Invalid prototype for " + Name + " prototype");
1830 Params.push_back(PtrTy);
1831 Params.push_back(PtrTy);
1832 const FunctionType *FTy = FunctionType::get(Type::VoidTy, Params, false);
1833 const PointerType *PFTy = PointerType::get(FTy);
1834 Value* Func = getVal(PFTy, ID);
1835 std::string InstName0(makeNameUnique("va0"));
1836 std::string InstName1(makeNameUnique("va1"));
1837 Args[0] = new BitCastInst(Args[0], PtrTy, InstName0, CurBB);
1838 Args[1] = new BitCastInst(Args[1], PtrTy, InstName1, CurBB);
1839 return new CallInst(Func, &Args[0], Args.size());
1845 const Type* upgradeGEPIndices(const Type* PTy,
1846 std::vector<ValueInfo> *Indices,
1847 std::vector<Value*> &VIndices,
1848 std::vector<Constant*> *CIndices = 0) {
1849 // Traverse the indices with a gep_type_iterator so we can build the list
1850 // of constant and value indices for use later. Also perform upgrades
1852 if (CIndices) CIndices->clear();
1853 for (unsigned i = 0, e = Indices->size(); i != e; ++i)
1854 VIndices.push_back((*Indices)[i].V);
1855 generic_gep_type_iterator<std::vector<Value*>::iterator>
1856 GTI = gep_type_begin(PTy, VIndices.begin(), VIndices.end()),
1857 GTE = gep_type_end(PTy, VIndices.begin(), VIndices.end());
1858 for (unsigned i = 0, e = Indices->size(); i != e && GTI != GTE; ++i, ++GTI) {
1859 Value *Index = VIndices[i];
1860 if (CIndices && !isa<Constant>(Index))
1861 error("Indices to constant getelementptr must be constants");
1862 // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte
1863 // struct indices to i32 struct indices with ZExt for compatibility.
1864 else if (isa<StructType>(*GTI)) { // Only change struct indices
1865 if (ConstantInt *CUI = dyn_cast<ConstantInt>(Index))
1866 if (CUI->getType()->getBitWidth() == 8)
1868 ConstantExpr::getCast(Instruction::ZExt, CUI, Type::Int32Ty);
1870 // Make sure that unsigned SequentialType indices are zext'd to
1871 // 64-bits if they were smaller than that because LLVM 2.0 will sext
1872 // all indices for SequentialType elements. We must retain the same
1873 // semantic (zext) for unsigned types.
1874 if (const IntegerType *Ity = dyn_cast<IntegerType>(Index->getType()))
1875 if (Ity->getBitWidth() < 64 && (*Indices)[i].S.isUnsigned()) {
1877 Index = ConstantExpr::getCast(Instruction::ZExt,
1878 cast<Constant>(Index), Type::Int64Ty);
1880 Index = CastInst::create(Instruction::ZExt, Index, Type::Int64Ty,
1881 makeNameUnique("gep"), CurBB);
1882 VIndices[i] = Index;
1885 // Add to the CIndices list, if requested.
1887 CIndices->push_back(cast<Constant>(Index));
1891 GetElementPtrInst::getIndexedType(PTy, &VIndices[0], VIndices.size(), true);
1893 error("Index list invalid for constant getelementptr");
1897 unsigned upgradeCallingConv(unsigned CC) {
1899 case OldCallingConv::C : return CallingConv::C;
1900 case OldCallingConv::CSRet : return CallingConv::C;
1901 case OldCallingConv::Fast : return CallingConv::Fast;
1902 case OldCallingConv::Cold : return CallingConv::Cold;
1903 case OldCallingConv::X86_StdCall : return CallingConv::X86_StdCall;
1904 case OldCallingConv::X86_FastCall: return CallingConv::X86_FastCall;
1910 Module* UpgradeAssembly(const std::string &infile, std::istream& in,
1911 bool debug, bool addAttrs)
1914 CurFilename = infile;
1917 AddAttributes = addAttrs;
1918 ObsoleteVarArgs = false;
1921 CurModule.CurrentModule = new Module(CurFilename);
1923 // Check to make sure the parser succeeded
1926 delete ParserResult;
1927 std::cerr << "llvm-upgrade: parse failed.\n";
1931 // Check to make sure that parsing produced a result
1932 if (!ParserResult) {
1933 std::cerr << "llvm-upgrade: no parse result.\n";
1937 // Reset ParserResult variable while saving its value for the result.
1938 Module *Result = ParserResult;
1941 //Not all functions use vaarg, so make a second check for ObsoleteVarArgs
1944 if ((F = Result->getFunction("llvm.va_start"))
1945 && F->getFunctionType()->getNumParams() == 0)
1946 ObsoleteVarArgs = true;
1947 if((F = Result->getFunction("llvm.va_copy"))
1948 && F->getFunctionType()->getNumParams() == 1)
1949 ObsoleteVarArgs = true;
1952 if (ObsoleteVarArgs && NewVarArgs) {
1953 error("This file is corrupt: it uses both new and old style varargs");
1957 if(ObsoleteVarArgs) {
1958 if(Function* F = Result->getFunction("llvm.va_start")) {
1959 if (F->arg_size() != 0) {
1960 error("Obsolete va_start takes 0 argument");
1966 //bar = alloca typeof(foo)
1970 const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
1971 const Type* ArgTy = F->getFunctionType()->getReturnType();
1972 const Type* ArgTyPtr = PointerType::get(ArgTy);
1973 Function* NF = cast<Function>(Result->getOrInsertFunction(
1974 "llvm.va_start", RetTy, ArgTyPtr, (Type *)0));
1976 while (!F->use_empty()) {
1977 CallInst* CI = cast<CallInst>(F->use_back());
1978 AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI);
1979 new CallInst(NF, bar, "", CI);
1980 Value* foo = new LoadInst(bar, "vastart.fix.2", CI);
1981 CI->replaceAllUsesWith(foo);
1982 CI->getParent()->getInstList().erase(CI);
1984 Result->getFunctionList().erase(F);
1987 if(Function* F = Result->getFunction("llvm.va_end")) {
1988 if(F->arg_size() != 1) {
1989 error("Obsolete va_end takes 1 argument");
1995 //bar = alloca 1 of typeof(foo)
1997 const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
1998 const Type* ArgTy = F->getFunctionType()->getParamType(0);
1999 const Type* ArgTyPtr = PointerType::get(ArgTy);
2000 Function* NF = cast<Function>(Result->getOrInsertFunction(
2001 "llvm.va_end", RetTy, ArgTyPtr, (Type *)0));
2003 while (!F->use_empty()) {
2004 CallInst* CI = cast<CallInst>(F->use_back());
2005 AllocaInst* bar = new AllocaInst(ArgTy, 0, "vaend.fix.1", CI);
2006 new StoreInst(CI->getOperand(1), bar, CI);
2007 new CallInst(NF, bar, "", CI);
2008 CI->getParent()->getInstList().erase(CI);
2010 Result->getFunctionList().erase(F);
2013 if(Function* F = Result->getFunction("llvm.va_copy")) {
2014 if(F->arg_size() != 1) {
2015 error("Obsolete va_copy takes 1 argument");
2020 //a = alloca 1 of typeof(foo)
2021 //b = alloca 1 of typeof(foo)
2026 const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
2027 const Type* ArgTy = F->getFunctionType()->getReturnType();
2028 const Type* ArgTyPtr = PointerType::get(ArgTy);
2029 Function* NF = cast<Function>(Result->getOrInsertFunction(
2030 "llvm.va_copy", RetTy, ArgTyPtr, ArgTyPtr, (Type *)0));
2032 while (!F->use_empty()) {
2033 CallInst* CI = cast<CallInst>(F->use_back());
2034 AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI);
2035 AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI);
2036 new StoreInst(CI->getOperand(1), b, CI);
2037 new CallInst(NF, a, b, "", CI);
2038 Value* foo = new LoadInst(a, "vacopy.fix.3", CI);
2039 CI->replaceAllUsesWith(foo);
2040 CI->getParent()->getInstList().erase(CI);
2042 Result->getFunctionList().erase(F);
2049 } // end llvm namespace
2051 using namespace llvm;
2055 /* Enabling traces. */
2060 /* Enabling verbose error messages. */
2061 #ifdef YYERROR_VERBOSE
2062 # undef YYERROR_VERBOSE
2063 # define YYERROR_VERBOSE 1
2065 # define YYERROR_VERBOSE 0
2068 /* Enabling the token table. */
2069 #ifndef YYTOKEN_TABLE
2070 # define YYTOKEN_TABLE 0
2073 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
2074 #line 1693 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
2075 typedef union YYSTYPE {
2076 llvm::Module *ModuleVal;
2077 llvm::Function *FunctionVal;
2078 std::pair<llvm::PATypeInfo, char*> *ArgVal;
2079 llvm::BasicBlock *BasicBlockVal;
2080 llvm::TermInstInfo TermInstVal;
2081 llvm::InstrInfo InstVal;
2082 llvm::ConstInfo ConstVal;
2083 llvm::ValueInfo ValueVal;
2084 llvm::PATypeInfo TypeVal;
2085 llvm::TypeInfo PrimType;
2086 llvm::PHIListInfo PHIList;
2087 std::list<llvm::PATypeInfo> *TypeList;
2088 std::vector<llvm::ValueInfo> *ValueList;
2089 std::vector<llvm::ConstInfo> *ConstVector;
2092 std::vector<std::pair<llvm::PATypeInfo,char*> > *ArgList;
2093 // Represent the RHS of PHI node
2094 std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable;
2096 llvm::GlobalValue::LinkageTypes Linkage;
2104 char *StrVal; // This memory is strdup'd!
2105 llvm::ValID ValIDVal; // strdup'd memory maybe!
2107 llvm::BinaryOps BinaryOpVal;
2108 llvm::TermOps TermOpVal;
2109 llvm::MemoryOps MemOpVal;
2110 llvm::OtherOps OtherOpVal;
2111 llvm::CastOps CastOpVal;
2112 llvm::ICmpInst::Predicate IPred;
2113 llvm::FCmpInst::Predicate FPred;
2114 llvm::Module::Endianness Endianness;
2116 /* Line 196 of yacc.c. */
2117 #line 2116 "UpgradeParser.tab.c"
2118 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
2119 # define YYSTYPE_IS_DECLARED 1
2120 # define YYSTYPE_IS_TRIVIAL 1
2125 /* Copy the second part of user declarations. */
2128 /* Line 219 of yacc.c. */
2129 #line 2128 "UpgradeParser.tab.c"
2131 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
2132 # define YYSIZE_T __SIZE_TYPE__
2134 #if ! defined (YYSIZE_T) && defined (size_t)
2135 # define YYSIZE_T size_t
2137 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
2138 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
2139 # define YYSIZE_T size_t
2141 #if ! defined (YYSIZE_T)
2142 # define YYSIZE_T unsigned int
2148 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
2149 # define YY_(msgid) dgettext ("bison-runtime", msgid)
2153 # define YY_(msgid) msgid
2157 #if ! defined (yyoverflow) || YYERROR_VERBOSE
2159 /* The parser invokes alloca or malloc; define the necessary symbols. */
2161 # ifdef YYSTACK_USE_ALLOCA
2162 # if YYSTACK_USE_ALLOCA
2164 # define YYSTACK_ALLOC __builtin_alloca
2166 # define YYSTACK_ALLOC alloca
2167 # if defined (__STDC__) || defined (__cplusplus)
2168 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
2169 # define YYINCLUDED_STDLIB_H
2175 # ifdef YYSTACK_ALLOC
2176 /* Pacify GCC's `empty if-body' warning. */
2177 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
2178 # ifndef YYSTACK_ALLOC_MAXIMUM
2179 /* The OS might guarantee only one guard page at the bottom of the stack,
2180 and a page size can be as small as 4096 bytes. So we cannot safely
2181 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
2182 to allow for a few compiler-allocated temporary stack slots. */
2183 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
2186 # define YYSTACK_ALLOC YYMALLOC
2187 # define YYSTACK_FREE YYFREE
2188 # ifndef YYSTACK_ALLOC_MAXIMUM
2189 # define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
2195 # define YYMALLOC malloc
2196 # if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
2197 && (defined (__STDC__) || defined (__cplusplus)))
2198 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
2202 # define YYFREE free
2203 # if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
2204 && (defined (__STDC__) || defined (__cplusplus)))
2205 void free (void *); /* INFRINGES ON USER NAME SPACE */
2212 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
2215 #if (! defined (yyoverflow) \
2216 && (! defined (__cplusplus) \
2217 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
2219 /* A type that is properly aligned for any stack member. */
2226 /* The size of the maximum gap between one aligned stack and the next. */
2227 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
2229 /* The size of an array large to enough to hold all stacks, each with
2231 # define YYSTACK_BYTES(N) \
2232 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
2233 + YYSTACK_GAP_MAXIMUM)
2235 /* Copy COUNT objects from FROM to TO. The source and destination do
2238 # if defined (__GNUC__) && 1 < __GNUC__
2239 # define YYCOPY(To, From, Count) \
2240 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
2242 # define YYCOPY(To, From, Count) \
2246 for (yyi = 0; yyi < (Count); yyi++) \
2247 (To)[yyi] = (From)[yyi]; \
2253 /* Relocate STACK from its old location to the new one. The
2254 local variables YYSIZE and YYSTACKSIZE give the old and new number of
2255 elements in the stack, and YYPTR gives the new location of the
2256 stack. Advance YYPTR to a properly aligned location for the next
2258 # define YYSTACK_RELOCATE(Stack) \
2261 YYSIZE_T yynewbytes; \
2262 YYCOPY (&yyptr->Stack, Stack, yysize); \
2263 Stack = &yyptr->Stack; \
2264 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
2265 yyptr += yynewbytes / sizeof (*yyptr); \
2271 #if defined (__STDC__) || defined (__cplusplus)
2272 typedef signed char yysigned_char;
2274 typedef short int yysigned_char;
2277 /* YYFINAL -- State number of the termination state. */
2279 /* YYLAST -- Last index in YYTABLE. */
2282 /* YYNTOKENS -- Number of terminals. */
2283 #define YYNTOKENS 166
2284 /* YYNNTS -- Number of nonterminals. */
2286 /* YYNRULES -- Number of rules. */
2287 #define YYNRULES 310
2288 /* YYNRULES -- Number of states. */
2289 #define YYNSTATES 606
2291 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
2292 #define YYUNDEFTOK 2
2293 #define YYMAXUTOK 406
2295 #define YYTRANSLATE(YYX) \
2296 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
2298 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
2299 static const unsigned char yytranslate[] =
2301 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2302 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2303 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2304 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2305 155, 156, 164, 2, 153, 2, 2, 2, 2, 2,
2306 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2307 160, 152, 161, 2, 2, 2, 2, 2, 2, 2,
2308 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2309 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2310 2, 157, 154, 159, 2, 2, 2, 2, 2, 165,
2311 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2312 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2313 158, 2, 2, 162, 2, 163, 2, 2, 2, 2,
2314 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2315 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2316 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2317 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2318 2, 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 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2323 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2324 2, 2, 2, 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, 1, 2, 3, 4,
2327 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2328 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
2329 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
2330 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
2331 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
2332 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2333 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
2334 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
2335 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
2336 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
2337 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2338 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
2339 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
2340 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
2341 145, 146, 147, 148, 149, 150, 151
2345 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
2347 static const unsigned short int yyprhs[] =
2349 0, 0, 3, 5, 7, 9, 11, 13, 15, 17,
2350 19, 21, 23, 25, 27, 29, 31, 33, 35, 37,
2351 39, 41, 43, 45, 47, 49, 51, 53, 55, 57,
2352 59, 61, 63, 65, 67, 69, 71, 73, 75, 77,
2353 79, 81, 83, 85, 87, 89, 91, 93, 95, 97,
2354 99, 101, 103, 105, 107, 109, 111, 113, 115, 117,
2355 119, 121, 123, 125, 127, 129, 131, 133, 135, 137,
2356 139, 141, 143, 145, 147, 149, 151, 153, 155, 157,
2357 159, 161, 164, 165, 167, 169, 171, 173, 175, 177,
2358 179, 180, 181, 183, 185, 187, 189, 191, 193, 196,
2359 197, 200, 201, 205, 208, 209, 211, 212, 216, 218,
2360 221, 223, 225, 227, 229, 231, 233, 235, 237, 239,
2361 241, 243, 245, 247, 249, 251, 253, 255, 257, 259,
2362 261, 264, 269, 275, 281, 285, 288, 294, 299, 302,
2363 304, 308, 310, 314, 316, 317, 322, 326, 330, 335,
2364 340, 344, 351, 357, 360, 363, 366, 369, 372, 375,
2365 378, 381, 384, 387, 394, 400, 409, 416, 423, 430,
2366 438, 446, 453, 460, 469, 478, 482, 484, 486, 488,
2367 490, 493, 496, 501, 504, 506, 511, 514, 519, 520,
2368 528, 529, 537, 538, 546, 547, 555, 559, 564, 565,
2369 567, 569, 571, 575, 579, 583, 587, 591, 595, 597,
2370 598, 600, 602, 604, 605, 608, 612, 614, 616, 620,
2371 622, 623, 632, 634, 636, 637, 642, 644, 646, 649,
2372 650, 652, 654, 655, 656, 662, 663, 665, 667, 669,
2373 671, 673, 675, 677, 679, 681, 685, 687, 693, 695,
2374 697, 699, 701, 704, 707, 710, 714, 717, 718, 720,
2375 722, 724, 727, 730, 734, 744, 754, 763, 777, 779,
2376 781, 788, 794, 797, 804, 812, 814, 818, 820, 821,
2377 824, 826, 832, 838, 844, 851, 858, 861, 866, 871,
2378 878, 883, 888, 893, 898, 905, 912, 915, 923, 925,
2379 928, 929, 931, 932, 936, 943, 947, 954, 957, 962,
2383 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
2384 static const short int yyrhs[] =
2386 200, 0, -1, 5, -1, 6, -1, 3, -1, 4,
2387 -1, 79, -1, 80, -1, 81, -1, 82, -1, 83,
2388 -1, 84, -1, 85, -1, 86, -1, 87, -1, 88,
2389 -1, 89, -1, 90, -1, 91, -1, 92, -1, 97,
2390 -1, 98, -1, 99, -1, 100, -1, 101, -1, 102,
2391 -1, 119, -1, 120, -1, 121, -1, 122, -1, 123,
2392 -1, 124, -1, 125, -1, 126, -1, 127, -1, 128,
2393 -1, 129, -1, 130, -1, 131, -1, 132, -1, 133,
2394 -1, 134, -1, 135, -1, 136, -1, 137, -1, 138,
2395 -1, 125, -1, 126, -1, 127, -1, 128, -1, 27,
2396 -1, 28, -1, 93, -1, 94, -1, 95, -1, 96,
2397 -1, 140, -1, 141, -1, 142, -1, 143, -1, 144,
2398 -1, 145, -1, 146, -1, 147, -1, 148, -1, 149,
2399 -1, 150, -1, 151, -1, 139, -1, 16, -1, 14,
2400 -1, 12, -1, 10, -1, 17, -1, 15, -1, 13,
2401 -1, 11, -1, 176, -1, 177, -1, 18, -1, 19,
2402 -1, 212, 152, -1, -1, 41, -1, 42, -1, 43,
2403 -1, 44, -1, 45, -1, 46, -1, 47, -1, -1,
2404 -1, 65, -1, 66, -1, 67, -1, 68, -1, 69,
2405 -1, 70, -1, 64, 4, -1, -1, 57, 4, -1,
2406 -1, 153, 57, 4, -1, 34, 24, -1, -1, 185,
2407 -1, -1, 153, 188, 187, -1, 185, -1, 57, 4,
2408 -1, 191, -1, 8, -1, 193, -1, 8, -1, 193,
2409 -1, 9, -1, 10, -1, 11, -1, 12, -1, 13,
2410 -1, 14, -1, 15, -1, 16, -1, 17, -1, 18,
2411 -1, 19, -1, 21, -1, 192, -1, 48, -1, 229,
2412 -1, 154, 4, -1, 190, 155, 195, 156, -1, 157,
2413 4, 158, 193, 159, -1, 160, 4, 158, 193, 161,
2414 -1, 162, 194, 163, -1, 162, 163, -1, 160, 162,
2415 194, 163, 161, -1, 160, 162, 163, 161, -1, 193,
2416 164, -1, 193, -1, 194, 153, 193, -1, 194, -1,
2417 194, 153, 37, -1, 37, -1, -1, 191, 157, 198,
2418 159, -1, 191, 157, 159, -1, 191, 165, 24, -1,
2419 191, 160, 198, 161, -1, 191, 162, 198, 163, -1,
2420 191, 162, 163, -1, 191, 160, 162, 198, 163, 161,
2421 -1, 191, 160, 162, 163, 161, -1, 191, 38, -1,
2422 191, 39, -1, 191, 229, -1, 191, 197, -1, 191,
2423 26, -1, 176, 168, -1, 177, 4, -1, 9, 27,
2424 -1, 9, 28, -1, 179, 7, -1, 175, 155, 196,
2425 36, 191, 156, -1, 110, 155, 196, 244, 156, -1,
2426 112, 155, 196, 153, 196, 153, 196, 156, -1, 169,
2427 155, 196, 153, 196, 156, -1, 170, 155, 196, 153,
2428 196, 156, -1, 171, 155, 196, 153, 196, 156, -1,
2429 103, 172, 155, 196, 153, 196, 156, -1, 104, 173,
2430 155, 196, 153, 196, 156, -1, 174, 155, 196, 153,
2431 196, 156, -1, 114, 155, 196, 153, 196, 156, -1,
2432 115, 155, 196, 153, 196, 153, 196, 156, -1, 116,
2433 155, 196, 153, 196, 153, 196, 156, -1, 198, 153,
2434 196, -1, 196, -1, 32, -1, 33, -1, 201, -1,
2435 201, 222, -1, 201, 224, -1, 201, 62, 61, 207,
2436 -1, 201, 25, -1, 202, -1, 202, 180, 20, 189,
2437 -1, 202, 224, -1, 202, 62, 61, 207, -1, -1,
2438 202, 180, 181, 199, 196, 203, 187, -1, -1, 202,
2439 180, 50, 199, 191, 204, 187, -1, -1, 202, 180,
2440 45, 199, 191, 205, 187, -1, -1, 202, 180, 47,
2441 199, 191, 206, 187, -1, 202, 51, 209, -1, 202,
2442 58, 152, 210, -1, -1, 24, -1, 56, -1, 55,
2443 -1, 53, 152, 208, -1, 54, 152, 4, -1, 52,
2444 152, 24, -1, 71, 152, 24, -1, 157, 211, 159,
2445 -1, 211, 153, 24, -1, 24, -1, -1, 22, -1,
2446 24, -1, 212, -1, -1, 191, 213, -1, 215, 153,
2447 214, -1, 214, -1, 215, -1, 215, 153, 37, -1,
2448 37, -1, -1, 182, 189, 212, 155, 216, 156, 186,
2449 183, -1, 29, -1, 162, -1, -1, 181, 220, 217,
2450 218, -1, 30, -1, 163, -1, 232, 221, -1, -1,
2451 45, -1, 47, -1, -1, -1, 31, 225, 223, 226,
2452 217, -1, -1, 63, -1, 3, -1, 4, -1, 7,
2453 -1, 27, -1, 28, -1, 38, -1, 39, -1, 26,
2454 -1, 160, 198, 161, -1, 197, -1, 61, 227, 24,
2455 153, 24, -1, 167, -1, 212, -1, 229, -1, 228,
2456 -1, 191, 230, -1, 232, 233, -1, 219, 233, -1,
2457 234, 180, 236, -1, 234, 238, -1, -1, 23, -1,
2458 77, -1, 78, -1, 72, 231, -1, 72, 8, -1,
2459 73, 21, 230, -1, 73, 9, 230, 153, 21, 230,
2460 153, 21, 230, -1, 74, 178, 230, 153, 21, 230,
2461 157, 237, 159, -1, 74, 178, 230, 153, 21, 230,
2462 157, 159, -1, 75, 182, 189, 230, 155, 241, 156,
2463 36, 21, 230, 235, 21, 230, -1, 235, -1, 76,
2464 -1, 237, 178, 228, 153, 21, 230, -1, 178, 228,
2465 153, 21, 230, -1, 180, 243, -1, 191, 157, 230,
2466 153, 230, 159, -1, 239, 153, 157, 230, 153, 230,
2467 159, -1, 231, -1, 240, 153, 231, -1, 240, -1,
2468 -1, 60, 59, -1, 59, -1, 169, 191, 230, 153,
2469 230, -1, 170, 191, 230, 153, 230, -1, 171, 191,
2470 230, 153, 230, -1, 103, 172, 191, 230, 153, 230,
2471 -1, 104, 173, 191, 230, 153, 230, -1, 49, 231,
2472 -1, 174, 231, 153, 231, -1, 175, 231, 36, 191,
2473 -1, 112, 231, 153, 231, 153, 231, -1, 113, 231,
2474 153, 191, -1, 117, 231, 153, 191, -1, 118, 231,
2475 153, 191, -1, 114, 231, 153, 231, -1, 115, 231,
2476 153, 231, 153, 231, -1, 116, 231, 153, 231, 153,
2477 231, -1, 111, 239, -1, 242, 182, 189, 230, 155,
2478 241, 156, -1, 246, -1, 153, 240, -1, -1, 35,
2479 -1, -1, 105, 191, 184, -1, 105, 191, 153, 15,
2480 230, 184, -1, 106, 191, 184, -1, 106, 191, 153,
2481 15, 230, 184, -1, 107, 231, -1, 245, 108, 191,
2482 230, -1, 245, 109, 231, 153, 191, 230, -1, 110,
2486 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
2487 static const unsigned short int yyrline[] =
2489 0, 1833, 1833, 1834, 1842, 1843, 1853, 1853, 1853, 1853,
2490 1853, 1853, 1853, 1853, 1853, 1853, 1853, 1857, 1857, 1857,
2491 1861, 1861, 1861, 1861, 1861, 1861, 1865, 1865, 1866, 1866,
2492 1867, 1867, 1868, 1868, 1869, 1869, 1873, 1873, 1874, 1874,
2493 1875, 1875, 1876, 1876, 1877, 1877, 1878, 1878, 1879, 1879,
2494 1880, 1881, 1884, 1884, 1884, 1884, 1888, 1888, 1888, 1888,
2495 1888, 1888, 1888, 1889, 1889, 1889, 1889, 1889, 1889, 1895,
2496 1895, 1895, 1895, 1899, 1899, 1899, 1899, 1903, 1903, 1907,
2497 1907, 1912, 1915, 1920, 1921, 1922, 1923, 1924, 1925, 1926,
2498 1927, 1931, 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1948,
2499 1949, 1957, 1958, 1966, 1975, 1976, 1983, 1984, 1988, 1992,
2500 2008, 2009, 2016, 2017, 2024, 2032, 2032, 2032, 2032, 2032,
2501 2032, 2032, 2033, 2033, 2033, 2033, 2033, 2038, 2042, 2046,
2502 2051, 2060, 2078, 2084, 2097, 2108, 2112, 2125, 2129, 2143,
2503 2147, 2154, 2155, 2161, 2168, 2180, 2210, 2223, 2246, 2274,
2504 2296, 2307, 2329, 2340, 2349, 2354, 2413, 2420, 2428, 2435,
2505 2442, 2446, 2450, 2459, 2474, 2487, 2496, 2524, 2537, 2546,
2506 2552, 2558, 2569, 2575, 2581, 2592, 2593, 2602, 2603, 2615,
2507 2624, 2625, 2626, 2627, 2628, 2644, 2664, 2666, 2668, 2668,
2508 2675, 2675, 2683, 2683, 2691, 2691, 2700, 2702, 2704, 2709,
2509 2723, 2724, 2728, 2731, 2739, 2743, 2750, 2754, 2758, 2762,
2510 2770, 2770, 2774, 2775, 2779, 2787, 2792, 2800, 2801, 2808,
2511 2815, 2819, 3000, 3000, 3004, 3004, 3014, 3014, 3018, 3023,
2512 3024, 3025, 3029, 3030, 3029, 3042, 3043, 3048, 3049, 3050,
2513 3051, 3055, 3059, 3060, 3061, 3062, 3083, 3087, 3101, 3102,
2514 3107, 3107, 3115, 3125, 3128, 3137, 3148, 3153, 3162, 3173,
2515 3173, 3176, 3180, 3184, 3189, 3199, 3217, 3226, 3291, 3295,
2516 3302, 3314, 3329, 3359, 3369, 3379, 3383, 3390, 3391, 3395,
2517 3398, 3404, 3423, 3441, 3457, 3471, 3485, 3496, 3514, 3523,
2518 3532, 3539, 3560, 3584, 3590, 3596, 3602, 3618, 3702, 3710,
2519 3711, 3715, 3716, 3720, 3726, 3733, 3739, 3746, 3753, 3766,
2524 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
2525 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
2526 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
2527 static const char *const yytname[] =
2529 "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "SINTVAL",
2530 "UINTVAL", "FPVAL", "VOID", "BOOL", "SBYTE", "UBYTE", "SHORT", "USHORT",
2531 "INT", "UINT", "LONG", "ULONG", "FLOAT", "DOUBLE", "TYPE", "LABEL",
2532 "VAR_ID", "LABELSTR", "STRINGCONSTANT", "IMPLEMENTATION",
2533 "ZEROINITIALIZER", "TRUETOK", "FALSETOK", "BEGINTOK", "ENDTOK",
2534 "DECLARE", "GLOBAL", "CONSTANT", "SECTION", "VOLATILE", "TO",
2535 "DOTDOTDOT", "NULL_TOK", "UNDEF", "CONST", "INTERNAL", "LINKONCE",
2536 "WEAK", "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "OPAQUE",
2537 "NOT", "EXTERNAL", "TARGET", "TRIPLE", "ENDIAN", "POINTERSIZE", "LITTLE",
2538 "BIG", "ALIGN", "DEPLIBS", "CALL", "TAIL", "ASM_TOK", "MODULE",
2539 "SIDEEFFECT", "CC_TOK", "CCC_TOK", "CSRETCC_TOK", "FASTCC_TOK",
2540 "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT",
2541 "RET", "BR", "SWITCH", "INVOKE", "UNREACHABLE", "UNWIND", "EXCEPT",
2542 "ADD", "SUB", "MUL", "DIV", "UDIV", "SDIV", "FDIV", "REM", "UREM",
2543 "SREM", "FREM", "AND", "OR", "XOR", "SHL", "SHR", "ASHR", "LSHR",
2544 "SETLE", "SETGE", "SETLT", "SETGT", "SETEQ", "SETNE", "ICMP", "FCMP",
2545 "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE", "GETELEMENTPTR", "PHI_TOK",
2546 "SELECT", "VAARG", "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR",
2547 "VAARG_old", "VANEXT_old", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", "ULT",
2548 "UGT", "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD",
2549 "UNO", "UEQ", "UNE", "CAST", "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT",
2550 "FPTOUI", "FPTOSI", "UITOFP", "SITOFP", "PTRTOINT", "INTTOPTR",
2551 "BITCAST", "'='", "','", "'\\\\'", "'('", "')'", "'['", "'x'", "']'",
2552 "'<'", "'>'", "'{'", "'}'", "'*'", "'c'", "$accept", "INTVAL",
2553 "EINT64VAL", "ArithmeticOps", "LogicalOps", "SetCondOps", "IPredicates",
2554 "FPredicates", "ShiftOps", "CastOps", "SIntType", "UIntType", "IntType",
2555 "FPType", "OptAssign", "OptLinkage", "OptCallingConv", "OptAlign",
2556 "OptCAlign", "SectionString", "OptSection", "GlobalVarAttributes",
2557 "GlobalVarAttribute", "TypesV", "UpRTypesV", "Types", "PrimType",
2558 "UpRTypes", "TypeListI", "ArgTypeListI", "ConstVal", "ConstExpr",
2559 "ConstVector", "GlobalType", "Module", "FunctionList", "ConstPool", "@1",
2560 "@2", "@3", "@4", "AsmBlock", "BigOrLittle", "TargetDefinition",
2561 "LibrariesDefinition", "LibList", "Name", "OptName", "ArgVal",
2562 "ArgListH", "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader",
2563 "@5", "END", "Function", "FnDeclareLinkage", "FunctionProto", "@6", "@7",
2564 "OptSideEffect", "ConstValueRef", "SymbolicValueRef", "ValueRef",
2565 "ResolvedVal", "BasicBlockList", "BasicBlock", "InstructionList",
2566 "Unwind", "BBTerminatorInst", "JumpTable", "Inst", "PHIList",
2567 "ValueRefList", "ValueRefListE", "OptTailCall", "InstVal", "IndexList",
2568 "OptVolatile", "MemoryInst", 0
2573 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
2575 static const unsigned short int yytoknum[] =
2577 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
2578 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
2579 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
2580 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
2581 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
2582 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
2583 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
2584 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
2585 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
2586 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
2587 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
2588 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
2589 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
2590 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
2591 395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
2592 405, 406, 61, 44, 92, 40, 41, 91, 120, 93,
2593 60, 62, 123, 125, 42, 99
2597 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
2598 static const unsigned char yyr1[] =
2600 0, 166, 167, 167, 168, 168, 169, 169, 169, 169,
2601 169, 169, 169, 169, 169, 169, 169, 170, 170, 170,
2602 171, 171, 171, 171, 171, 171, 172, 172, 172, 172,
2603 172, 172, 172, 172, 172, 172, 173, 173, 173, 173,
2604 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
2605 173, 173, 174, 174, 174, 174, 175, 175, 175, 175,
2606 175, 175, 175, 175, 175, 175, 175, 175, 175, 176,
2607 176, 176, 176, 177, 177, 177, 177, 178, 178, 179,
2608 179, 180, 180, 181, 181, 181, 181, 181, 181, 181,
2609 181, 182, 182, 182, 182, 182, 182, 182, 182, 183,
2610 183, 184, 184, 185, 186, 186, 187, 187, 188, 188,
2611 189, 189, 190, 190, 191, 192, 192, 192, 192, 192,
2612 192, 192, 192, 192, 192, 192, 192, 193, 193, 193,
2613 193, 193, 193, 193, 193, 193, 193, 193, 193, 194,
2614 194, 195, 195, 195, 195, 196, 196, 196, 196, 196,
2615 196, 196, 196, 196, 196, 196, 196, 196, 196, 196,
2616 196, 196, 196, 197, 197, 197, 197, 197, 197, 197,
2617 197, 197, 197, 197, 197, 198, 198, 199, 199, 200,
2618 201, 201, 201, 201, 201, 202, 202, 202, 203, 202,
2619 204, 202, 205, 202, 206, 202, 202, 202, 202, 207,
2620 208, 208, 209, 209, 209, 209, 210, 211, 211, 211,
2621 212, 212, 213, 213, 214, 215, 215, 216, 216, 216,
2622 216, 217, 218, 218, 220, 219, 221, 221, 222, 223,
2623 223, 223, 225, 226, 224, 227, 227, 228, 228, 228,
2624 228, 228, 228, 228, 228, 228, 228, 228, 229, 229,
2625 230, 230, 231, 232, 232, 233, 234, 234, 234, 235,
2626 235, 236, 236, 236, 236, 236, 236, 236, 236, 236,
2627 237, 237, 238, 239, 239, 240, 240, 241, 241, 242,
2628 242, 243, 243, 243, 243, 243, 243, 243, 243, 243,
2629 243, 243, 243, 243, 243, 243, 243, 243, 243, 244,
2630 244, 245, 245, 246, 246, 246, 246, 246, 246, 246,
2634 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
2635 static const unsigned char yyr2[] =
2637 0, 2, 1, 1, 1, 1, 1, 1, 1, 1,
2638 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2639 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2640 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2641 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2642 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2643 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2644 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2645 1, 2, 0, 1, 1, 1, 1, 1, 1, 1,
2646 0, 0, 1, 1, 1, 1, 1, 1, 2, 0,
2647 2, 0, 3, 2, 0, 1, 0, 3, 1, 2,
2648 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2649 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2650 2, 4, 5, 5, 3, 2, 5, 4, 2, 1,
2651 3, 1, 3, 1, 0, 4, 3, 3, 4, 4,
2652 3, 6, 5, 2, 2, 2, 2, 2, 2, 2,
2653 2, 2, 2, 6, 5, 8, 6, 6, 6, 7,
2654 7, 6, 6, 8, 8, 3, 1, 1, 1, 1,
2655 2, 2, 4, 2, 1, 4, 2, 4, 0, 7,
2656 0, 7, 0, 7, 0, 7, 3, 4, 0, 1,
2657 1, 1, 3, 3, 3, 3, 3, 3, 1, 0,
2658 1, 1, 1, 0, 2, 3, 1, 1, 3, 1,
2659 0, 8, 1, 1, 0, 4, 1, 1, 2, 0,
2660 1, 1, 0, 0, 5, 0, 1, 1, 1, 1,
2661 1, 1, 1, 1, 1, 3, 1, 5, 1, 1,
2662 1, 1, 2, 2, 2, 3, 2, 0, 1, 1,
2663 1, 2, 2, 3, 9, 9, 8, 13, 1, 1,
2664 6, 5, 2, 6, 7, 1, 3, 1, 0, 2,
2665 1, 5, 5, 5, 6, 6, 2, 4, 4, 6,
2666 4, 4, 4, 4, 6, 6, 2, 7, 1, 2,
2667 0, 1, 0, 3, 6, 3, 6, 2, 4, 6,
2671 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
2672 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
2673 means the default is an error. */
2674 static const unsigned short int yydefact[] =
2676 198, 0, 90, 184, 1, 183, 232, 83, 84, 85,
2677 86, 87, 88, 89, 0, 224, 257, 180, 181, 257,
2678 210, 211, 0, 0, 0, 90, 0, 186, 229, 0,
2679 91, 258, 254, 82, 226, 227, 228, 253, 0, 0,
2680 0, 0, 196, 0, 0, 0, 0, 0, 0, 0,
2681 81, 230, 231, 233, 199, 182, 0, 92, 93, 94,
2682 95, 96, 97, 0, 0, 302, 256, 0, 0, 0,
2683 0, 209, 197, 187, 2, 3, 111, 115, 116, 117,
2684 118, 119, 120, 121, 122, 123, 124, 125, 126, 128,
2685 0, 0, 0, 0, 248, 185, 0, 110, 127, 114,
2686 249, 129, 177, 178, 0, 0, 0, 0, 91, 98,
2687 0, 222, 223, 225, 301, 0, 280, 0, 0, 0,
2688 0, 91, 269, 259, 260, 6, 7, 8, 9, 10,
2689 11, 12, 13, 14, 15, 16, 17, 18, 19, 52,
2690 53, 54, 55, 20, 21, 22, 23, 24, 25, 0,
2691 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2692 0, 0, 0, 68, 56, 57, 58, 59, 60, 61,
2693 62, 63, 64, 65, 66, 67, 0, 0, 0, 0,
2694 0, 268, 255, 91, 272, 0, 298, 204, 201, 200,
2695 202, 203, 205, 208, 0, 130, 0, 0, 0, 113,
2696 135, 139, 0, 144, 138, 192, 194, 190, 115, 116,
2697 117, 118, 119, 120, 121, 122, 123, 124, 125, 0,
2698 0, 0, 0, 188, 234, 0, 0, 286, 279, 262,
2699 261, 0, 0, 72, 76, 71, 75, 70, 74, 69,
2700 73, 77, 78, 0, 0, 26, 27, 28, 29, 30,
2701 31, 32, 33, 34, 35, 0, 50, 51, 46, 47,
2702 48, 49, 36, 37, 38, 39, 40, 41, 42, 43,
2703 44, 45, 0, 101, 101, 307, 0, 0, 296, 0,
2704 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2705 0, 0, 0, 0, 0, 206, 0, 0, 0, 0,
2706 0, 134, 143, 141, 0, 106, 106, 106, 160, 161,
2707 4, 5, 158, 159, 162, 157, 153, 154, 0, 0,
2708 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2709 0, 0, 0, 0, 156, 155, 106, 220, 237, 238,
2710 239, 244, 240, 241, 242, 243, 235, 0, 246, 251,
2711 250, 252, 0, 263, 0, 0, 0, 0, 0, 303,
2712 0, 305, 300, 0, 0, 0, 0, 0, 0, 0,
2713 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2714 207, 112, 112, 137, 0, 140, 0, 131, 0, 193,
2715 195, 191, 0, 0, 0, 0, 0, 0, 0, 146,
2716 176, 0, 0, 0, 150, 0, 147, 0, 0, 0,
2717 0, 0, 189, 219, 213, 216, 217, 0, 236, 0,
2718 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2719 310, 0, 0, 0, 290, 293, 0, 0, 291, 292,
2720 0, 0, 0, 287, 288, 0, 308, 0, 132, 133,
2721 136, 142, 0, 0, 108, 106, 0, 0, 300, 0,
2722 0, 0, 0, 0, 145, 135, 114, 0, 148, 149,
2723 0, 0, 0, 0, 0, 212, 214, 0, 104, 0,
2724 245, 0, 0, 278, 0, 0, 101, 102, 101, 275,
2725 299, 0, 0, 0, 0, 0, 281, 282, 283, 278,
2726 0, 103, 109, 107, 0, 0, 0, 0, 0, 0,
2727 0, 175, 152, 0, 0, 0, 0, 0, 0, 218,
2728 215, 105, 99, 0, 0, 0, 277, 0, 284, 285,
2729 0, 304, 306, 0, 0, 0, 289, 294, 295, 0,
2730 309, 0, 0, 164, 0, 0, 0, 0, 151, 0,
2731 0, 0, 0, 0, 0, 221, 247, 0, 0, 0,
2732 276, 273, 0, 297, 0, 0, 0, 172, 0, 0,
2733 166, 167, 168, 171, 163, 100, 0, 266, 0, 0,
2734 0, 274, 169, 170, 0, 0, 0, 264, 0, 265,
2735 0, 0, 165, 173, 174, 0, 0, 0, 0, 0,
2736 0, 271, 0, 0, 270, 267
2739 /* YYDEFGOTO[NTERM-NUM]. */
2740 static const short int yydefgoto[] =
2742 -1, 94, 312, 329, 330, 331, 255, 272, 332, 333,
2743 219, 220, 243, 221, 25, 15, 63, 555, 359, 454,
2744 522, 389, 455, 95, 96, 222, 98, 99, 202, 304,
2745 400, 348, 401, 104, 1, 2, 3, 336, 307, 305,
2746 306, 55, 190, 42, 72, 194, 100, 476, 415, 416,
2747 417, 64, 113, 16, 30, 36, 17, 53, 18, 28,
2748 108, 419, 349, 101, 351, 489, 19, 32, 33, 181,
2749 182, 579, 66, 278, 526, 527, 183, 184, 430, 185,
2753 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
2755 #define YYPACT_NINF -542
2756 static const short int yypact[] =
2758 -542, 13, 162, 567, -542, -542, -542, -542, -542, -542,
2759 -542, -542, -542, -542, 83, -542, 19, -542, -542, -14,
2760 -542, -542, 50, -87, 87, 233, 27, -542, 123, 141,
2761 175, -542, -542, 98, -542, -542, -542, -542, 33, 40,
2762 66, 68, -542, 14, 141, 1265, 156, 156, 156, 156,
2763 -542, -542, -542, -542, -542, -542, 221, -542, -542, -542,
2764 -542, -542, -542, 1265, -19, 1479, -542, 204, 135, 226,
2765 227, 235, -542, -542, -542, -542, 81, -542, -542, -542,
2766 -542, -542, -542, -542, -542, -542, -542, -542, -542, -542,
2767 256, 257, 4, 15, -542, -542, 108, -542, -542, 12,
2768 -542, -542, -542, -542, 1306, 1306, 1306, 1326, 175, -542,
2769 98, -542, -542, -542, -542, 1306, -542, 205, 1367, 116,
2770 479, 175, -542, -542, -542, -542, -542, -542, -542, -542,
2771 -542, -542, -542, -542, -542, -542, -542, -542, -542, -542,
2772 -542, -542, -542, -542, -542, -542, -542, -542, -542, 355,
2773 429, 1306, 1306, 1306, 1306, 1306, 1306, 1306, 1306, 1306,
2774 1306, 1306, 1306, -542, -542, -542, -542, -542, -542, -542,
2775 -542, -542, -542, -542, -542, -542, 1306, 1306, 1306, 1306,
2776 1306, -542, -542, 175, -542, 86, -542, -542, -542, -542,
2777 -542, -542, -542, -542, -13, -542, 110, 111, 75, -542,
2778 -542, 12, -81, 1046, -542, -542, -542, -542, 174, 208,
2779 266, 210, 267, 212, 268, 230, 277, 275, 278, 246,
2780 280, 279, 566, -542, -542, 136, 766, -542, -542, 81,
2781 -542, 766, 766, -542, -542, -542, -542, -542, -542, -542,
2782 -542, -542, -542, 766, 1265, -542, -542, -542, -542, -542,
2783 -542, -542, -542, -542, -542, 1306, -542, -542, -542, -542,
2784 -542, -542, -542, -542, -542, -542, -542, -542, -542, -542,
2785 -542, -542, 1306, 137, 145, -542, 766, 132, 146, 147,
2786 148, 149, 151, 152, 158, 160, 766, 766, 766, 161,
2787 281, 1265, 1306, 1306, 291, -542, 1306, 1306, 155, -27,
2788 1306, -542, -542, 165, 163, 176, 176, 176, -542, -542,
2789 -542, -542, -542, -542, -542, -542, -542, -542, 355, 429,
2790 172, 177, 178, 179, 182, 1087, 1387, 529, 311, 184,
2791 185, 186, 188, 189, -542, -542, 176, 1107, -542, -542,
2792 -542, -542, -542, -542, -542, -542, 282, 1326, -542, -542,
2793 -542, -542, 193, -542, 194, 766, 766, 766, 7, -542,
2794 20, -542, 195, 766, 192, 1306, 1306, 1306, 1306, 1306,
2795 1306, 1306, 200, 201, 206, 1306, 1306, 766, 766, 207,
2796 -542, -59, -149, -542, 196, 12, 1148, -542, 44, -542,
2797 -542, -542, 203, 211, 1326, 1326, 1326, 1326, 1326, -542,
2798 -542, -8, 741, -82, -542, 10, -542, 1326, 1326, 1326,
2799 1326, 1326, -542, -542, 98, -542, 214, 209, -542, 337,
2800 -34, 342, 348, 215, 218, 219, 766, 371, 766, 1306,
2801 -542, 223, 766, 224, -542, -542, 225, 234, -542, -542,
2802 766, 766, 766, -542, -542, 228, -542, 1306, -542, -542,
2803 -542, -542, 362, 375, -542, 176, 1326, 1326, 195, 236,
2804 237, 240, 243, 1326, -542, 238, -25, 11, -542, -542,
2805 244, 245, 247, 250, 352, -542, -542, 1205, 370, 252,
2806 -542, 766, 766, 1306, 766, 766, 258, -542, 258, -542,
2807 259, 766, 264, 1306, 1306, 1306, -542, -542, -542, 1306,
2808 766, -542, -542, -542, 270, 271, 263, 1326, 1326, 1326,
2809 1326, -542, -542, 260, 1326, 1326, 1326, 1326, 1306, -542,
2810 -542, -542, 368, 402, 274, 276, 259, 287, -542, -542,
2811 374, -542, -542, 1306, 285, 766, -542, -542, -542, 290,
2812 -542, 1326, 1326, -542, 283, 295, 284, 294, -542, 296,
2813 297, 299, 302, 303, 430, -542, -542, 414, 41, 425,
2814 -542, -542, 305, -542, 306, 310, 1326, -542, 1326, 1326,
2815 -542, -542, -542, -542, -542, -542, 766, -542, 893, 144,
2816 448, -542, -542, -542, 314, 315, 316, -542, 331, -542,
2817 893, 766, -542, -542, -542, 464, 334, 180, 766, 481,
2818 482, -542, 766, 766, -542, -542
2821 /* YYPGOTO[NTERM-NUM]. */
2822 static const short int yypgoto[] =
2824 -542, -542, -542, 435, 439, 441, 191, 197, 442, 445,
2825 -119, -116, -541, -542, 478, 489, -107, -542, -267, 37,
2826 -542, -238, -542, -60, -542, -45, -542, -74, -51, -542,
2827 -101, 300, -252, 134, -542, -542, -542, -542, -542, -542,
2828 -542, 473, -542, -542, -542, -542, 8, -542, 46, -542,
2829 -542, 410, -542, -542, -542, -542, -542, -542, 518, -542,
2830 -542, -542, -528, 142, -90, -113, -542, 505, -542, -72,
2831 -542, -542, -542, -542, 97, 28, -542, -542, 70, -542,
2835 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
2836 positive, shift that token. If negative, reduce the rule which
2837 number is the opposite. If zero, do what YYDEFACT says.
2838 If YYTABLE_NINF, syntax error. */
2839 #define YYTABLE_NINF -180
2840 static const short int yytable[] =
2842 97, 241, 227, 110, 242, 230, 223, 361, 197, 31,
2843 111, 26, 449, 4, 244, 204, 34, 578, 97, 201,
2844 74, 75, 426, 199, 77, 78, 79, 80, 81, 82,
2845 83, 84, 85, 86, 87, 428, 88, 20, 590, 21,
2846 275, 26, 31, 279, 280, 281, 282, 283, 284, 285,
2847 588, 233, 234, 235, 236, 237, 238, 239, 240, 205,
2848 206, 207, 596, 89, 427, 43, 289, 290, 390, 391,
2849 226, 463, 300, 226, 403, 405, 291, 427, 452, 468,
2850 74, 75, 301, 199, 77, 78, 79, 80, 81, 82,
2851 83, 84, 85, 86, 87, 420, 88, 20, 412, 21,
2852 448, 453, 38, 39, 40, 204, 273, 274, 226, 276,
2853 277, 226, 226, 226, 226, 226, 226, 226, 225, 463,
2854 20, 41, 21, 89, 201, 231, 300, 480, -139, 201,
2855 -112, 286, 287, 288, 226, 226, 384, 232, -139, 204,
2856 294, 352, 353, 112, 29, 463, 295, 299, 44, 35,
2857 467, 464, 303, 354, 233, 234, 235, 236, 237, 238,
2858 239, 240, -179, 463, 463, 54, 198, -112, 51, 90,
2859 52, 71, 91, 469, 513, 92, 204, 93, 200, 50,
2860 379, 105, 106, 107, 355, 67, 362, 5, 102, 103,
2861 188, 189, 68, 6, 292, 293, 372, 373, 374, 97,
2862 577, 308, 309, 7, 8, 9, 10, 11, 12, 13,
2863 356, -72, -72, -71, -71, -70, -70, 503, 69, 531,
2864 70, 532, 381, 382, 14, 109, 385, 357, 187, 90,
2865 191, 377, 91, -69, -69, 92, -113, 93, 298, 56,
2866 57, 58, 59, 60, 61, 62, 97, 378, 226, 310,
2867 311, 192, 433, 45, 435, 436, 437, 123, 124, 193,
2868 195, 196, 443, 203, 228, 423, 424, 425, 296, 297,
2869 -76, -75, -74, 431, 7, 8, 9, 10, 46, 12,
2870 47, -73, -79, 48, 313, -80, 314, 445, 446, 363,
2871 358, 337, 414, 458, 459, 460, 461, 462, 360, 364,
2872 365, 366, 367, 589, 368, 369, 470, 471, 472, 473,
2873 474, 370, 385, 371, 375, 380, 383, 376, 386, 387,
2874 226, 434, 226, 226, 226, 438, 439, 394, 466, 388,
2875 226, 444, 395, 396, 397, 406, 486, 398, 488, 407,
2876 408, 409, 492, 410, 411, 418, 421, 422, 429, 432,
2877 496, 497, 498, 440, 441, 504, 505, 450, 456, 442,
2878 447, 479, 511, 481, 335, 478, 457, 477, 350, 482,
2879 483, 484, 485, 350, 350, 487, 491, 493, 494, 502,
2880 536, 537, 538, 499, 226, 350, 501, 495, 518, 507,
2881 508, 524, 525, 509, 528, 529, 510, 514, 515, 512,
2882 516, 534, 500, 517, 452, 523, 544, 545, 546, 547,
2883 540, 530, 533, 549, 550, 551, 552, 535, 350, 543,
2884 560, 548, 475, 541, 542, 554, 556, 557, 350, 350,
2885 350, 427, 414, 558, 575, 576, 566, 568, 226, 241,
2886 564, 565, 242, 559, 561, 562, 563, 569, 226, 226,
2887 226, 567, 570, 571, 226, 572, 256, 257, 573, 574,
2888 241, 580, 582, 242, 581, 584, 583, 585, 586, 591,
2889 592, 593, 594, 553, 245, 246, 247, 248, 249, 250,
2890 251, 252, 253, 254, 595, 598, 587, 599, 226, 233,
2891 234, 235, 236, 237, 238, 239, 240, 350, 350, 350,
2892 176, 597, 602, 603, 177, 350, 178, 179, 601, 392,
2893 180, 65, 604, 605, 49, 521, 393, 73, 224, 350,
2894 350, 27, 334, 520, 37, 600, 490, 539, 506, 0,
2895 0, 0, 0, 0, 74, 75, 0, 199, 208, 209,
2896 210, 211, 212, 213, 214, 215, 216, 217, 218, 0,
2897 88, 20, 0, 21, 258, 259, 260, 261, 262, 263,
2898 264, 265, 266, 267, 268, 269, 270, 271, 350, 0,
2899 350, 74, 75, 0, 350, 0, 0, 89, 0, 0,
2900 0, 0, 350, 350, 350, 0, 0, -82, 20, 20,
2901 21, 21, 315, 0, 0, 0, 0, 0, 6, -82,
2902 -82, 0, 0, 0, 316, 317, 0, 0, -82, -82,
2903 -82, -82, -82, -82, -82, 0, 0, -82, 22, 0,
2904 0, 0, 0, 350, 350, 23, 350, 350, 0, 24,
2905 0, 0, 0, 350, 0, 0, 0, 0, 0, 0,
2906 0, 0, 350, 0, 0, 125, 126, 127, 128, 129,
2907 130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
2908 140, 141, 142, 143, 144, 145, 146, 147, 148, 318,
2909 319, 0, 0, 0, 0, 0, 320, 350, 321, 0,
2910 322, 323, 324, 90, 0, 0, 91, 0, 0, 92,
2911 0, 93, 404, 0, 0, 0, 0, 0, 0, 0,
2912 0, 0, 0, 0, 0, 163, 164, 165, 166, 167,
2913 168, 169, 170, 171, 172, 173, 174, 175, 350, 0,
2914 0, 0, 0, 325, 0, 0, 326, 0, 327, 0,
2915 0, 328, 0, 350, 0, 0, 0, 0, 0, 0,
2916 350, 0, 0, 0, 350, 350, 74, 75, 0, 199,
2917 208, 209, 210, 211, 212, 213, 214, 215, 216, 217,
2918 218, 0, 88, 20, 0, 21, 0, 0, 0, 338,
2919 339, 74, 75, 340, 0, 0, 0, 0, 0, 0,
2920 0, 0, 0, 0, 0, 0, 0, 0, 20, 89,
2921 21, 0, 341, 342, 343, 0, 0, 0, 0, 0,
2922 0, 0, 0, 0, 344, 345, 0, 0, 0, 0,
2923 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2924 0, 0, 0, 0, 0, 0, 0, 346, 0, 0,
2925 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2926 0, 0, 0, 0, 0, 125, 126, 127, 128, 129,
2927 130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
2928 140, 141, 142, 143, 144, 145, 146, 147, 148, 318,
2929 319, 0, 0, 0, 0, 0, 320, 0, 321, 0,
2930 322, 323, 324, 0, 0, 0, 0, 0, 0, 0,
2931 0, 0, 0, 0, 0, 90, 338, 339, 91, 0,
2932 340, 92, 0, 93, 465, 163, 164, 165, 166, 167,
2933 168, 169, 170, 171, 172, 173, 174, 175, 0, 341,
2934 342, 343, 0, 0, 0, 0, 347, 0, 0, 0,
2935 0, 344, 345, 0, 0, 0, 0, 0, 0, 0,
2936 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2937 0, 0, 0, 0, 346, 0, 0, 0, 0, 0,
2938 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2939 0, 0, 125, 126, 127, 128, 129, 130, 131, 132,
2940 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
2941 143, 144, 145, 146, 147, 148, 318, 319, 0, 0,
2942 0, 0, 0, 320, 0, 321, 0, 322, 323, 324,
2943 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2944 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2945 0, 0, 163, 164, 165, 166, 167, 168, 169, 170,
2946 171, 172, 173, 174, 175, 0, 0, 0, 0, 0,
2947 0, 74, 75, 347, 199, 77, 78, 79, 80, 81,
2948 82, 83, 84, 85, 86, 87, 0, 88, 20, 0,
2949 21, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2950 0, 0, 0, 302, 0, 0, 0, 0, 0, 0,
2951 0, 0, 74, 75, 89, 199, 208, 209, 210, 211,
2952 212, 213, 214, 215, 216, 217, 218, 0, 88, 20,
2953 0, 21, 74, 75, 0, 199, 77, 78, 79, 80,
2954 81, 82, 83, 84, 85, 86, 87, 0, 88, 20,
2955 0, 21, 0, 0, 0, 89, 0, 0, 0, 0,
2956 0, 0, 0, 0, 413, 0, 0, 0, 0, 0,
2957 0, 0, 0, 74, 75, 89, 199, 77, 78, 79,
2958 80, 81, 82, 83, 84, 85, 86, 87, 0, 88,
2959 20, 0, 21, 0, 0, 0, 0, 0, 0, 0,
2960 0, 0, 0, 0, 0, 451, 0, 0, 0, 0,
2961 0, 0, 0, 0, 0, 0, 89, 0, 0, 0,
2962 90, 0, 0, 91, 0, 0, 92, 0, 93, 0,
2963 74, 75, 0, 199, 77, 78, 79, 80, 81, 82,
2964 83, 84, 85, 86, 87, 0, 88, 20, 0, 21,
2965 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2966 0, 90, 519, 0, 91, 0, 399, 92, 0, 93,
2967 0, 0, 0, 89, 0, 0, 0, 0, 0, 0,
2968 0, 90, 0, 0, 91, 0, 0, 92, 0, 93,
2969 74, 75, 0, 76, 77, 78, 79, 80, 81, 82,
2970 83, 84, 85, 86, 87, 0, 88, 20, 0, 21,
2971 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2972 0, 0, 90, 0, 0, 91, 0, 0, 92, 0,
2973 93, 74, 75, 89, 199, 77, 78, 79, 80, 81,
2974 82, 83, 84, 85, 86, 87, 0, 88, 20, 0,
2975 21, 74, 75, 0, 199, 208, 209, 210, 211, 212,
2976 213, 214, 215, 216, 217, 218, 0, 88, 20, 0,
2977 21, 0, 0, 0, 89, 0, 0, 0, 0, 90,
2978 0, 0, 91, 0, 0, 92, 0, 93, 0, 0,
2979 0, 0, 74, 75, 89, 229, 77, 78, 79, 80,
2980 81, 82, 83, 84, 85, 86, 87, 0, 88, 20,
2981 0, 21, 74, 75, 0, 199, 208, 209, 210, 211,
2982 212, 213, 214, 215, 216, 217, 218, 0, 88, 20,
2983 0, 21, 0, 0, 0, 89, 0, 0, 0, 90,
2984 0, 0, 91, 0, 0, 92, 0, 93, 0, 0,
2985 0, 0, 0, 0, 0, 89, 0, 0, 0, 0,
2986 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2987 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2988 90, 0, 0, 91, 0, 0, 92, 0, 93, 0,
2989 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2990 90, 0, 0, 91, 0, 0, 92, 0, 93, 0,
2991 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2992 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2993 0, 0, 0, 0, 114, 0, 0, 0, 0, 0,
2994 0, 90, 0, 0, 91, 0, 0, 92, 115, 93,
2995 0, 0, 0, 0, 0, 0, 0, 0, 116, 117,
2996 0, 90, 0, 0, 91, 0, 0, 92, 0, 402,
2997 0, 118, 119, 120, 121, 122, 123, 124, 125, 126,
2998 127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
2999 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
3000 147, 148, 149, 150, 151, 152, 153, 0, 0, 154,
3001 155, 156, 157, 158, 159, 160, 161, 162, 0, 0,
3002 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3003 0, 0, 0, 0, 0, 0, 0, 0, 163, 164,
3004 165, 166, 167, 168, 169, 170, 171, 172, 173, 174,
3008 static const short int yycheck[] =
3010 45, 120, 115, 63, 120, 118, 107, 274, 4, 23,
3011 29, 3, 161, 0, 121, 164, 30, 558, 63, 93,
3012 5, 6, 15, 8, 9, 10, 11, 12, 13, 14,
3013 15, 16, 17, 18, 19, 15, 21, 22, 579, 24,
3014 153, 33, 23, 156, 157, 158, 159, 160, 161, 162,
3015 578, 10, 11, 12, 13, 14, 15, 16, 17, 104,
3016 105, 106, 590, 48, 57, 152, 179, 180, 306, 307,
3017 115, 153, 153, 118, 326, 327, 183, 57, 34, 161,
3018 5, 6, 163, 8, 9, 10, 11, 12, 13, 14,
3019 15, 16, 17, 18, 19, 347, 21, 22, 336, 24,
3020 159, 57, 52, 53, 54, 164, 151, 152, 153, 154,
3021 155, 156, 157, 158, 159, 160, 161, 162, 110, 153,
3022 22, 71, 24, 48, 198, 9, 153, 161, 153, 203,
3023 155, 176, 177, 178, 179, 180, 163, 21, 163, 164,
3024 153, 231, 232, 162, 61, 153, 159, 198, 61, 163,
3025 402, 159, 203, 243, 10, 11, 12, 13, 14, 15,
3026 16, 17, 0, 153, 153, 24, 162, 155, 45, 154,
3027 47, 157, 157, 163, 163, 160, 164, 162, 163, 152,
3028 293, 47, 48, 49, 244, 152, 276, 25, 32, 33,
3029 55, 56, 152, 31, 108, 109, 286, 287, 288, 244,
3030 159, 27, 28, 41, 42, 43, 44, 45, 46, 47,
3031 255, 3, 4, 3, 4, 3, 4, 455, 152, 486,
3032 152, 488, 296, 297, 62, 4, 300, 272, 24, 154,
3033 4, 291, 157, 3, 4, 160, 155, 162, 163, 64,
3034 65, 66, 67, 68, 69, 70, 291, 292, 293, 3,
3035 4, 24, 365, 20, 367, 368, 369, 77, 78, 24,
3036 4, 4, 375, 155, 59, 355, 356, 357, 158, 158,
3037 4, 4, 4, 363, 41, 42, 43, 44, 45, 46,
3038 47, 4, 7, 50, 4, 7, 7, 377, 378, 157,
3039 153, 155, 337, 394, 395, 396, 397, 398, 153, 153,
3040 153, 153, 153, 159, 153, 153, 407, 408, 409, 410,
3041 411, 153, 386, 153, 153, 24, 161, 36, 153, 156,
3042 365, 366, 367, 368, 369, 370, 371, 155, 402, 153,
3043 375, 376, 155, 155, 155, 24, 426, 155, 428, 155,
3044 155, 155, 432, 155, 155, 63, 153, 153, 153, 157,
3045 440, 441, 442, 153, 153, 456, 457, 161, 155, 153,
3046 153, 24, 463, 21, 222, 156, 155, 153, 226, 21,
3047 155, 153, 153, 231, 232, 4, 153, 153, 153, 4,
3048 493, 494, 495, 155, 429, 243, 24, 153, 36, 153,
3049 153, 481, 482, 153, 484, 485, 153, 153, 153, 161,
3050 153, 491, 447, 153, 34, 153, 507, 508, 509, 510,
3051 500, 153, 153, 514, 515, 516, 517, 153, 276, 156,
3052 533, 161, 414, 153, 153, 57, 24, 153, 286, 287,
3053 288, 57, 477, 157, 4, 21, 153, 153, 483, 558,
3054 541, 542, 558, 156, 159, 535, 156, 153, 493, 494,
3055 495, 156, 156, 156, 499, 156, 27, 28, 156, 156,
3056 579, 36, 156, 579, 159, 566, 156, 568, 569, 21,
3057 156, 156, 156, 518, 119, 120, 121, 122, 123, 124,
3058 125, 126, 127, 128, 153, 21, 576, 153, 533, 10,
3059 11, 12, 13, 14, 15, 16, 17, 355, 356, 357,
3060 65, 591, 21, 21, 65, 363, 65, 65, 598, 318,
3061 65, 33, 602, 603, 25, 478, 319, 44, 108, 377,
3062 378, 3, 222, 477, 19, 597, 429, 499, 458, -1,
3063 -1, -1, -1, -1, 5, 6, -1, 8, 9, 10,
3064 11, 12, 13, 14, 15, 16, 17, 18, 19, -1,
3065 21, 22, -1, 24, 125, 126, 127, 128, 129, 130,
3066 131, 132, 133, 134, 135, 136, 137, 138, 426, -1,
3067 428, 5, 6, -1, 432, -1, -1, 48, -1, -1,
3068 -1, -1, 440, 441, 442, -1, -1, 20, 22, 22,
3069 24, 24, 26, -1, -1, -1, -1, -1, 31, 32,
3070 33, -1, -1, -1, 38, 39, -1, -1, 41, 42,
3071 43, 44, 45, 46, 47, -1, -1, 50, 51, -1,
3072 -1, -1, -1, 481, 482, 58, 484, 485, -1, 62,
3073 -1, -1, -1, 491, -1, -1, -1, -1, -1, -1,
3074 -1, -1, 500, -1, -1, 79, 80, 81, 82, 83,
3075 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
3076 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
3077 104, -1, -1, -1, -1, -1, 110, 535, 112, -1,
3078 114, 115, 116, 154, -1, -1, 157, -1, -1, 160,
3079 -1, 162, 163, -1, -1, -1, -1, -1, -1, -1,
3080 -1, -1, -1, -1, -1, 139, 140, 141, 142, 143,
3081 144, 145, 146, 147, 148, 149, 150, 151, 576, -1,
3082 -1, -1, -1, 157, -1, -1, 160, -1, 162, -1,
3083 -1, 165, -1, 591, -1, -1, -1, -1, -1, -1,
3084 598, -1, -1, -1, 602, 603, 5, 6, -1, 8,
3085 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
3086 19, -1, 21, 22, -1, 24, -1, -1, -1, 3,
3087 4, 5, 6, 7, -1, -1, -1, -1, -1, -1,
3088 -1, -1, -1, -1, -1, -1, -1, -1, 22, 48,
3089 24, -1, 26, 27, 28, -1, -1, -1, -1, -1,
3090 -1, -1, -1, -1, 38, 39, -1, -1, -1, -1,
3091 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3092 -1, -1, -1, -1, -1, -1, -1, 61, -1, -1,
3093 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3094 -1, -1, -1, -1, -1, 79, 80, 81, 82, 83,
3095 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
3096 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
3097 104, -1, -1, -1, -1, -1, 110, -1, 112, -1,
3098 114, 115, 116, -1, -1, -1, -1, -1, -1, -1,
3099 -1, -1, -1, -1, -1, 154, 3, 4, 157, -1,
3100 7, 160, -1, 162, 163, 139, 140, 141, 142, 143,
3101 144, 145, 146, 147, 148, 149, 150, 151, -1, 26,
3102 27, 28, -1, -1, -1, -1, 160, -1, -1, -1,
3103 -1, 38, 39, -1, -1, -1, -1, -1, -1, -1,
3104 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3105 -1, -1, -1, -1, 61, -1, -1, -1, -1, -1,
3106 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3107 -1, -1, 79, 80, 81, 82, 83, 84, 85, 86,
3108 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
3109 97, 98, 99, 100, 101, 102, 103, 104, -1, -1,
3110 -1, -1, -1, 110, -1, 112, -1, 114, 115, 116,
3111 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3112 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3113 -1, -1, 139, 140, 141, 142, 143, 144, 145, 146,
3114 147, 148, 149, 150, 151, -1, -1, -1, -1, -1,
3115 -1, 5, 6, 160, 8, 9, 10, 11, 12, 13,
3116 14, 15, 16, 17, 18, 19, -1, 21, 22, -1,
3117 24, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3118 -1, -1, -1, 37, -1, -1, -1, -1, -1, -1,
3119 -1, -1, 5, 6, 48, 8, 9, 10, 11, 12,
3120 13, 14, 15, 16, 17, 18, 19, -1, 21, 22,
3121 -1, 24, 5, 6, -1, 8, 9, 10, 11, 12,
3122 13, 14, 15, 16, 17, 18, 19, -1, 21, 22,
3123 -1, 24, -1, -1, -1, 48, -1, -1, -1, -1,
3124 -1, -1, -1, -1, 37, -1, -1, -1, -1, -1,
3125 -1, -1, -1, 5, 6, 48, 8, 9, 10, 11,
3126 12, 13, 14, 15, 16, 17, 18, 19, -1, 21,
3127 22, -1, 24, -1, -1, -1, -1, -1, -1, -1,
3128 -1, -1, -1, -1, -1, 37, -1, -1, -1, -1,
3129 -1, -1, -1, -1, -1, -1, 48, -1, -1, -1,
3130 154, -1, -1, 157, -1, -1, 160, -1, 162, -1,
3131 5, 6, -1, 8, 9, 10, 11, 12, 13, 14,
3132 15, 16, 17, 18, 19, -1, 21, 22, -1, 24,
3133 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3134 -1, 154, 37, -1, 157, -1, 159, 160, -1, 162,
3135 -1, -1, -1, 48, -1, -1, -1, -1, -1, -1,
3136 -1, 154, -1, -1, 157, -1, -1, 160, -1, 162,
3137 5, 6, -1, 8, 9, 10, 11, 12, 13, 14,
3138 15, 16, 17, 18, 19, -1, 21, 22, -1, 24,
3139 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3140 -1, -1, 154, -1, -1, 157, -1, -1, 160, -1,
3141 162, 5, 6, 48, 8, 9, 10, 11, 12, 13,
3142 14, 15, 16, 17, 18, 19, -1, 21, 22, -1,
3143 24, 5, 6, -1, 8, 9, 10, 11, 12, 13,
3144 14, 15, 16, 17, 18, 19, -1, 21, 22, -1,
3145 24, -1, -1, -1, 48, -1, -1, -1, -1, 154,
3146 -1, -1, 157, -1, -1, 160, -1, 162, -1, -1,
3147 -1, -1, 5, 6, 48, 8, 9, 10, 11, 12,
3148 13, 14, 15, 16, 17, 18, 19, -1, 21, 22,
3149 -1, 24, 5, 6, -1, 8, 9, 10, 11, 12,
3150 13, 14, 15, 16, 17, 18, 19, -1, 21, 22,
3151 -1, 24, -1, -1, -1, 48, -1, -1, -1, 154,
3152 -1, -1, 157, -1, -1, 160, -1, 162, -1, -1,
3153 -1, -1, -1, -1, -1, 48, -1, -1, -1, -1,
3154 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3155 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3156 154, -1, -1, 157, -1, -1, 160, -1, 162, -1,
3157 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3158 154, -1, -1, 157, -1, -1, 160, -1, 162, -1,
3159 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3160 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3161 -1, -1, -1, -1, 35, -1, -1, -1, -1, -1,
3162 -1, 154, -1, -1, 157, -1, -1, 160, 49, 162,
3163 -1, -1, -1, -1, -1, -1, -1, -1, 59, 60,
3164 -1, 154, -1, -1, 157, -1, -1, 160, -1, 162,
3165 -1, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3166 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
3167 91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
3168 101, 102, 103, 104, 105, 106, 107, -1, -1, 110,
3169 111, 112, 113, 114, 115, 116, 117, 118, -1, -1,
3170 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3171 -1, -1, -1, -1, -1, -1, -1, -1, 139, 140,
3172 141, 142, 143, 144, 145, 146, 147, 148, 149, 150,
3176 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
3177 symbol of state STATE-NUM. */
3178 static const unsigned char yystos[] =
3180 0, 200, 201, 202, 0, 25, 31, 41, 42, 43,
3181 44, 45, 46, 47, 62, 181, 219, 222, 224, 232,
3182 22, 24, 51, 58, 62, 180, 212, 224, 225, 61,
3183 220, 23, 233, 234, 30, 163, 221, 233, 52, 53,
3184 54, 71, 209, 152, 61, 20, 45, 47, 50, 181,
3185 152, 45, 47, 223, 24, 207, 64, 65, 66, 67,
3186 68, 69, 70, 182, 217, 180, 238, 152, 152, 152,
3187 152, 157, 210, 207, 5, 6, 8, 9, 10, 11,
3188 12, 13, 14, 15, 16, 17, 18, 19, 21, 48,
3189 154, 157, 160, 162, 167, 189, 190, 191, 192, 193,
3190 212, 229, 32, 33, 199, 199, 199, 199, 226, 4,
3191 189, 29, 162, 218, 35, 49, 59, 60, 72, 73,
3192 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
3193 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
3194 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
3195 104, 105, 106, 107, 110, 111, 112, 113, 114, 115,
3196 116, 117, 118, 139, 140, 141, 142, 143, 144, 145,
3197 146, 147, 148, 149, 150, 151, 169, 170, 171, 174,
3198 175, 235, 236, 242, 243, 245, 246, 24, 55, 56,
3199 208, 4, 24, 24, 211, 4, 4, 4, 162, 8,
3200 163, 193, 194, 155, 164, 191, 191, 191, 9, 10,
3201 11, 12, 13, 14, 15, 16, 17, 18, 19, 176,
3202 177, 179, 191, 196, 217, 212, 191, 231, 59, 8,
3203 231, 9, 21, 10, 11, 12, 13, 14, 15, 16,
3204 17, 176, 177, 178, 182, 119, 120, 121, 122, 123,
3205 124, 125, 126, 127, 128, 172, 27, 28, 125, 126,
3206 127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
3207 137, 138, 173, 191, 191, 231, 191, 191, 239, 231,
3208 231, 231, 231, 231, 231, 231, 191, 191, 191, 231,
3209 231, 182, 108, 109, 153, 159, 158, 158, 163, 194,
3210 153, 163, 37, 194, 195, 205, 206, 204, 27, 28,
3211 3, 4, 168, 4, 7, 26, 38, 39, 103, 104,
3212 110, 112, 114, 115, 116, 157, 160, 162, 165, 169,
3213 170, 171, 174, 175, 197, 229, 203, 155, 3, 4,
3214 7, 26, 27, 28, 38, 39, 61, 160, 197, 228,
3215 229, 230, 230, 230, 230, 189, 191, 191, 153, 184,
3216 153, 184, 230, 157, 153, 153, 153, 153, 153, 153,
3217 153, 153, 230, 230, 230, 153, 36, 189, 191, 231,
3218 24, 193, 193, 161, 163, 193, 153, 156, 153, 187,
3219 187, 187, 172, 173, 155, 155, 155, 155, 155, 159,
3220 196, 198, 162, 198, 163, 198, 24, 155, 155, 155,
3221 155, 155, 187, 37, 191, 214, 215, 216, 63, 227,
3222 198, 153, 153, 230, 230, 230, 15, 57, 15, 153,
3223 244, 230, 157, 231, 191, 231, 231, 231, 191, 191,
3224 153, 153, 153, 231, 191, 230, 230, 153, 159, 161,
3225 161, 37, 34, 57, 185, 188, 155, 155, 196, 196,
3226 196, 196, 196, 153, 159, 163, 193, 198, 161, 163,
3227 196, 196, 196, 196, 196, 212, 213, 153, 156, 24,
3228 161, 21, 21, 155, 153, 153, 230, 4, 230, 231,
3229 240, 153, 230, 153, 153, 153, 230, 230, 230, 155,
3230 191, 24, 4, 187, 196, 196, 244, 153, 153, 153,
3231 153, 196, 161, 163, 153, 153, 153, 153, 36, 37,
3232 214, 185, 186, 153, 230, 230, 240, 241, 230, 230,
3233 153, 184, 184, 153, 230, 153, 231, 231, 231, 241,
3234 230, 153, 153, 156, 196, 196, 196, 196, 161, 196,
3235 196, 196, 196, 191, 57, 183, 24, 153, 157, 156,
3236 231, 159, 230, 156, 196, 196, 153, 156, 153, 153,
3237 156, 156, 156, 156, 156, 4, 21, 159, 178, 237,
3238 36, 159, 156, 156, 196, 196, 196, 230, 228, 159,
3239 178, 21, 156, 156, 156, 153, 228, 230, 21, 153,
3240 235, 230, 21, 21, 230, 230
3243 #define yyerrok (yyerrstatus = 0)
3244 #define yyclearin (yychar = YYEMPTY)
3245 #define YYEMPTY (-2)
3248 #define YYACCEPT goto yyacceptlab
3249 #define YYABORT goto yyabortlab
3250 #define YYERROR goto yyerrorlab
3253 /* Like YYERROR except do call yyerror. This remains here temporarily
3254 to ease the transition to the new meaning of YYERROR, for GCC.
3255 Once GCC version 2 has supplanted version 1, this can go. */
3257 #define YYFAIL goto yyerrlab
3259 #define YYRECOVERING() (!!yyerrstatus)
3261 #define YYBACKUP(Token, Value) \
3263 if (yychar == YYEMPTY && yylen == 1) \
3267 yytoken = YYTRANSLATE (yychar); \
3273 yyerror (YY_("syntax error: cannot back up")); \
3280 #define YYERRCODE 256
3283 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
3284 If N is 0, then set CURRENT to the empty location which ends
3285 the previous symbol: RHS[0] (always defined). */
3287 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
3288 #ifndef YYLLOC_DEFAULT
3289 # define YYLLOC_DEFAULT(Current, Rhs, N) \
3293 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
3294 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
3295 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
3296 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
3300 (Current).first_line = (Current).last_line = \
3301 YYRHSLOC (Rhs, 0).last_line; \
3302 (Current).first_column = (Current).last_column = \
3303 YYRHSLOC (Rhs, 0).last_column; \
3309 /* YY_LOCATION_PRINT -- Print the location on the stream.
3310 This macro was not mandated originally: define only if we know
3311 we won't break user code: when these are the locations we know. */
3313 #ifndef YY_LOCATION_PRINT
3314 # if YYLTYPE_IS_TRIVIAL
3315 # define YY_LOCATION_PRINT(File, Loc) \
3316 fprintf (File, "%d.%d-%d.%d", \
3317 (Loc).first_line, (Loc).first_column, \
3318 (Loc).last_line, (Loc).last_column)
3320 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
3325 /* YYLEX -- calling `yylex' with the right arguments. */
3328 # define YYLEX yylex (YYLEX_PARAM)
3330 # define YYLEX yylex ()
3333 /* Enable debugging if requested. */
3337 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
3338 # define YYFPRINTF fprintf
3341 # define YYDPRINTF(Args) \
3347 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
3351 YYFPRINTF (stderr, "%s ", Title); \
3352 yysymprint (stderr, \
3354 YYFPRINTF (stderr, "\n"); \
3358 /*------------------------------------------------------------------.
3359 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
3361 `------------------------------------------------------------------*/
3363 #if defined (__STDC__) || defined (__cplusplus)
3365 yy_stack_print (short int *bottom, short int *top)
3368 yy_stack_print (bottom, top)
3373 YYFPRINTF (stderr, "Stack now");
3374 for (/* Nothing. */; bottom <= top; ++bottom)
3375 YYFPRINTF (stderr, " %d", *bottom);
3376 YYFPRINTF (stderr, "\n");
3379 # define YY_STACK_PRINT(Bottom, Top) \
3382 yy_stack_print ((Bottom), (Top)); \
3386 /*------------------------------------------------.
3387 | Report that the YYRULE is going to be reduced. |
3388 `------------------------------------------------*/
3390 #if defined (__STDC__) || defined (__cplusplus)
3392 yy_reduce_print (int yyrule)
3395 yy_reduce_print (yyrule)
3400 unsigned long int yylno = yyrline[yyrule];
3401 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
3403 /* Print the symbols being reduced, and their result. */
3404 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
3405 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
3406 YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
3409 # define YY_REDUCE_PRINT(Rule) \
3412 yy_reduce_print (Rule); \
3415 /* Nonzero means print parse trace. It is left uninitialized so that
3416 multiple parsers can coexist. */
3418 #else /* !YYDEBUG */
3419 # define YYDPRINTF(Args)
3420 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
3421 # define YY_STACK_PRINT(Bottom, Top)
3422 # define YY_REDUCE_PRINT(Rule)
3423 #endif /* !YYDEBUG */
3426 /* YYINITDEPTH -- initial size of the parser's stacks. */
3428 # define YYINITDEPTH 200
3431 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
3432 if the built-in stack extension method is used).
3434 Do not make this value too large; the results are undefined if
3435 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
3436 evaluated with infinite-precision integer arithmetic. */
3439 # define YYMAXDEPTH 10000
3447 # if defined (__GLIBC__) && defined (_STRING_H)
3448 # define yystrlen strlen
3450 /* Return the length of YYSTR. */
3452 # if defined (__STDC__) || defined (__cplusplus)
3453 yystrlen (const char *yystr)
3459 const char *yys = yystr;
3461 while (*yys++ != '\0')
3464 return yys - yystr - 1;
3470 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
3471 # define yystpcpy stpcpy
3473 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
3476 # if defined (__STDC__) || defined (__cplusplus)
3477 yystpcpy (char *yydest, const char *yysrc)
3479 yystpcpy (yydest, yysrc)
3485 const char *yys = yysrc;
3487 while ((*yyd++ = *yys++) != '\0')
3496 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
3497 quotes and backslashes, so that it's suitable for yyerror. The
3498 heuristic is that double-quoting is unnecessary unless the string
3499 contains an apostrophe, a comma, or backslash (other than
3500 backslash-backslash). YYSTR is taken from yytname. If YYRES is
3501 null, do not copy; instead, return the length of what the result
3504 yytnamerr (char *yyres, const char *yystr)
3509 char const *yyp = yystr;
3516 goto do_not_strip_quotes;
3520 goto do_not_strip_quotes;
3533 do_not_strip_quotes: ;
3537 return yystrlen (yystr);
3539 return yystpcpy (yyres, yystr) - yyres;
3543 #endif /* YYERROR_VERBOSE */
3548 /*--------------------------------.
3549 | Print this symbol on YYOUTPUT. |
3550 `--------------------------------*/
3552 #if defined (__STDC__) || defined (__cplusplus)
3554 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
3557 yysymprint (yyoutput, yytype, yyvaluep)
3563 /* Pacify ``unused variable'' warnings. */
3566 if (yytype < YYNTOKENS)
3567 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
3569 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
3573 if (yytype < YYNTOKENS)
3574 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
3581 YYFPRINTF (yyoutput, ")");
3584 #endif /* ! YYDEBUG */
3585 /*-----------------------------------------------.
3586 | Release the memory associated to this symbol. |
3587 `-----------------------------------------------*/
3589 #if defined (__STDC__) || defined (__cplusplus)
3591 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
3594 yydestruct (yymsg, yytype, yyvaluep)
3600 /* Pacify ``unused variable'' warnings. */
3605 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
3616 /* Prevent warnings from -Wmissing-prototypes. */
3618 #ifdef YYPARSE_PARAM
3619 # if defined (__STDC__) || defined (__cplusplus)
3620 int yyparse (void *YYPARSE_PARAM);
3624 #else /* ! YYPARSE_PARAM */
3625 #if defined (__STDC__) || defined (__cplusplus)
3630 #endif /* ! YYPARSE_PARAM */
3634 /* The look-ahead symbol. */
3637 /* The semantic value of the look-ahead symbol. */
3640 /* Number of syntax errors so far. */
3649 #ifdef YYPARSE_PARAM
3650 # if defined (__STDC__) || defined (__cplusplus)
3651 int yyparse (void *YYPARSE_PARAM)
3653 int yyparse (YYPARSE_PARAM)
3654 void *YYPARSE_PARAM;
3656 #else /* ! YYPARSE_PARAM */
3657 #if defined (__STDC__) || defined (__cplusplus)
3671 /* Number of tokens to shift before error messages enabled. */
3673 /* Look-ahead token as an internal (translated) token number. */
3676 /* Three stacks and their tools:
3677 `yyss': related to states,
3678 `yyvs': related to semantic values,
3679 `yyls': related to locations.
3681 Refer to the stacks thru separate pointers, to allow yyoverflow
3682 to reallocate them elsewhere. */
3684 /* The state stack. */
3685 short int yyssa[YYINITDEPTH];
3686 short int *yyss = yyssa;
3689 /* The semantic value stack. */
3690 YYSTYPE yyvsa[YYINITDEPTH];
3691 YYSTYPE *yyvs = yyvsa;
3696 #define YYPOPSTACK (yyvsp--, yyssp--)
3698 YYSIZE_T yystacksize = YYINITDEPTH;
3700 /* The variables used to return semantic value and location from the
3705 /* When reducing, the number of symbols on the RHS of the reduced
3709 YYDPRINTF ((stderr, "Starting parse\n"));
3714 yychar = YYEMPTY; /* Cause a token to be read. */
3716 /* Initialize stack pointers.
3717 Waste one element of value and location stack
3718 so that they stay on the same level as the state stack.
3719 The wasted elements are never initialized. */
3726 /*------------------------------------------------------------.
3727 | yynewstate -- Push a new state, which is found in yystate. |
3728 `------------------------------------------------------------*/
3730 /* In all cases, when you get here, the value and location stacks
3731 have just been pushed. so pushing a state here evens the stacks.
3738 if (yyss + yystacksize - 1 <= yyssp)
3740 /* Get the current used size of the three stacks, in elements. */
3741 YYSIZE_T yysize = yyssp - yyss + 1;
3745 /* Give user a chance to reallocate the stack. Use copies of
3746 these so that the &'s don't force the real ones into
3748 YYSTYPE *yyvs1 = yyvs;
3749 short int *yyss1 = yyss;
3752 /* Each stack pointer address is followed by the size of the
3753 data in use in that stack, in bytes. This used to be a
3754 conditional around just the two extra args, but that might
3755 be undefined if yyoverflow is a macro. */
3756 yyoverflow (YY_("memory exhausted"),
3757 &yyss1, yysize * sizeof (*yyssp),
3758 &yyvs1, yysize * sizeof (*yyvsp),
3765 #else /* no yyoverflow */
3766 # ifndef YYSTACK_RELOCATE
3767 goto yyexhaustedlab;
3769 /* Extend the stack our own way. */
3770 if (YYMAXDEPTH <= yystacksize)
3771 goto yyexhaustedlab;
3773 if (YYMAXDEPTH < yystacksize)
3774 yystacksize = YYMAXDEPTH;
3777 short int *yyss1 = yyss;
3778 union yyalloc *yyptr =
3779 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
3781 goto yyexhaustedlab;
3782 YYSTACK_RELOCATE (yyss);
3783 YYSTACK_RELOCATE (yyvs);
3785 # undef YYSTACK_RELOCATE
3787 YYSTACK_FREE (yyss1);
3790 #endif /* no yyoverflow */
3792 yyssp = yyss + yysize - 1;
3793 yyvsp = yyvs + yysize - 1;
3796 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
3797 (unsigned long int) yystacksize));
3799 if (yyss + yystacksize - 1 <= yyssp)
3803 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
3812 /* Do appropriate processing given the current state. */
3813 /* Read a look-ahead token if we need one and don't already have one. */
3816 /* First try to decide what to do without reference to look-ahead token. */
3818 yyn = yypact[yystate];
3819 if (yyn == YYPACT_NINF)
3822 /* Not known => get a look-ahead token if don't already have one. */
3824 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
3825 if (yychar == YYEMPTY)
3827 YYDPRINTF ((stderr, "Reading a token: "));
3831 if (yychar <= YYEOF)
3833 yychar = yytoken = YYEOF;
3834 YYDPRINTF ((stderr, "Now at end of input.\n"));
3838 yytoken = YYTRANSLATE (yychar);
3839 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
3842 /* If the proper action on seeing token YYTOKEN is to reduce or to
3843 detect an error, take that action. */
3845 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
3850 if (yyn == 0 || yyn == YYTABLE_NINF)
3859 /* Shift the look-ahead token. */
3860 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
3862 /* Discard the token being shifted unless it is eof. */
3863 if (yychar != YYEOF)
3869 /* Count tokens shifted since error; after three, turn off error
3878 /*-----------------------------------------------------------.
3879 | yydefault -- do the default action for the current state. |
3880 `-----------------------------------------------------------*/
3882 yyn = yydefact[yystate];
3888 /*-----------------------------.
3889 | yyreduce -- Do a reduction. |
3890 `-----------------------------*/
3892 /* yyn is the number of a rule to reduce with. */
3895 /* If YYLEN is nonzero, implement the default value of the action:
3898 Otherwise, the following line sets YYVAL to garbage.
3899 This behavior is undocumented and Bison
3900 users should not rely upon it. Assigning to YYVAL
3901 unconditionally makes the parser a bit smaller, and it avoids a
3902 GCC warning that YYVAL may be used uninitialized. */
3903 yyval = yyvsp[1-yylen];
3906 YY_REDUCE_PRINT (yyn);
3910 #line 1834 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3912 if ((yyvsp[0].UIntVal) > (uint32_t)INT32_MAX) // Outside of my range!
3913 error("Value too large for type");
3914 (yyval.SIntVal) = (int32_t)(yyvsp[0].UIntVal);
3919 #line 1843 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3921 if ((yyvsp[0].UInt64Val) > (uint64_t)INT64_MAX) // Outside of my range!
3922 error("Value too large for type");
3923 (yyval.SInt64Val) = (int64_t)(yyvsp[0].UInt64Val);
3928 #line 1865 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3929 { (yyval.IPred) = ICmpInst::ICMP_EQ; ;}
3933 #line 1865 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3934 { (yyval.IPred) = ICmpInst::ICMP_NE; ;}
3938 #line 1866 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3939 { (yyval.IPred) = ICmpInst::ICMP_SLT; ;}
3943 #line 1866 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3944 { (yyval.IPred) = ICmpInst::ICMP_SGT; ;}
3948 #line 1867 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3949 { (yyval.IPred) = ICmpInst::ICMP_SLE; ;}
3953 #line 1867 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3954 { (yyval.IPred) = ICmpInst::ICMP_SGE; ;}
3958 #line 1868 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3959 { (yyval.IPred) = ICmpInst::ICMP_ULT; ;}
3963 #line 1868 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3964 { (yyval.IPred) = ICmpInst::ICMP_UGT; ;}
3968 #line 1869 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3969 { (yyval.IPred) = ICmpInst::ICMP_ULE; ;}
3973 #line 1869 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3974 { (yyval.IPred) = ICmpInst::ICMP_UGE; ;}
3978 #line 1873 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3979 { (yyval.FPred) = FCmpInst::FCMP_OEQ; ;}
3983 #line 1873 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3984 { (yyval.FPred) = FCmpInst::FCMP_ONE; ;}
3988 #line 1874 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3989 { (yyval.FPred) = FCmpInst::FCMP_OLT; ;}
3993 #line 1874 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3994 { (yyval.FPred) = FCmpInst::FCMP_OGT; ;}
3998 #line 1875 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3999 { (yyval.FPred) = FCmpInst::FCMP_OLE; ;}
4003 #line 1875 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4004 { (yyval.FPred) = FCmpInst::FCMP_OGE; ;}
4008 #line 1876 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4009 { (yyval.FPred) = FCmpInst::FCMP_ORD; ;}
4013 #line 1876 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4014 { (yyval.FPred) = FCmpInst::FCMP_UNO; ;}
4018 #line 1877 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4019 { (yyval.FPred) = FCmpInst::FCMP_UEQ; ;}
4023 #line 1877 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4024 { (yyval.FPred) = FCmpInst::FCMP_UNE; ;}
4028 #line 1878 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4029 { (yyval.FPred) = FCmpInst::FCMP_ULT; ;}
4033 #line 1878 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4034 { (yyval.FPred) = FCmpInst::FCMP_UGT; ;}
4038 #line 1879 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4039 { (yyval.FPred) = FCmpInst::FCMP_ULE; ;}
4043 #line 1879 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4044 { (yyval.FPred) = FCmpInst::FCMP_UGE; ;}
4048 #line 1880 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4049 { (yyval.FPred) = FCmpInst::FCMP_TRUE; ;}
4053 #line 1881 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4054 { (yyval.FPred) = FCmpInst::FCMP_FALSE; ;}
4058 #line 1912 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4060 (yyval.StrVal) = (yyvsp[-1].StrVal);
4065 #line 1915 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4072 #line 1920 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4073 { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
4077 #line 1921 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4078 { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
4082 #line 1922 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4083 { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
4087 #line 1923 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4088 { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;}
4092 #line 1924 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4093 { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
4097 #line 1925 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4098 { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
4102 #line 1926 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4103 { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
4107 #line 1927 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4108 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
4112 #line 1931 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4113 { (yyval.UIntVal) = OldCallingConv::C; ;}
4117 #line 1932 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4118 { (yyval.UIntVal) = OldCallingConv::C; ;}
4122 #line 1933 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4123 { (yyval.UIntVal) = OldCallingConv::CSRet; ;}
4127 #line 1934 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4128 { (yyval.UIntVal) = OldCallingConv::Fast; ;}
4132 #line 1935 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4133 { (yyval.UIntVal) = OldCallingConv::Cold; ;}
4137 #line 1936 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4138 { (yyval.UIntVal) = OldCallingConv::X86_StdCall; ;}
4142 #line 1937 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4143 { (yyval.UIntVal) = OldCallingConv::X86_FastCall; ;}
4147 #line 1938 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4149 if ((unsigned)(yyvsp[0].UInt64Val) != (yyvsp[0].UInt64Val))
4150 error("Calling conv too large");
4151 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
4156 #line 1948 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4157 { (yyval.UIntVal) = 0; ;}
4161 #line 1949 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4163 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
4164 if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
4165 error("Alignment must be a power of two");
4170 #line 1957 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4171 { (yyval.UIntVal) = 0; ;}
4175 #line 1958 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4177 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
4178 if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
4179 error("Alignment must be a power of two");
4184 #line 1966 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4186 for (unsigned i = 0, e = strlen((yyvsp[0].StrVal)); i != e; ++i)
4187 if ((yyvsp[0].StrVal)[i] == '"' || (yyvsp[0].StrVal)[i] == '\\')
4188 error("Invalid character in section name");
4189 (yyval.StrVal) = (yyvsp[0].StrVal);
4194 #line 1975 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4195 { (yyval.StrVal) = 0; ;}
4199 #line 1976 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4200 { (yyval.StrVal) = (yyvsp[0].StrVal); ;}
4204 #line 1983 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4209 #line 1984 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4214 #line 1988 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4216 CurGV->setSection((yyvsp[0].StrVal));
4217 free((yyvsp[0].StrVal));
4222 #line 1992 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4224 if ((yyvsp[0].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[0].UInt64Val)))
4225 error("Alignment must be a power of two");
4226 CurGV->setAlignment((yyvsp[0].UInt64Val));
4232 #line 2009 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4234 (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T);
4235 (yyval.TypeVal).S.makeSignless();
4240 #line 2017 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4242 (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T);
4243 (yyval.TypeVal).S.makeSignless();
4248 #line 2024 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4250 if (!UpRefs.empty())
4251 error("Invalid upreference in type: " + (*(yyvsp[0].TypeVal).PAT)->getDescription());
4252 (yyval.TypeVal) = (yyvsp[0].TypeVal);
4257 #line 2038 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4259 (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T);
4260 (yyval.TypeVal).S.copy((yyvsp[0].PrimType).S);
4265 #line 2042 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4267 (yyval.TypeVal).PAT = new PATypeHolder(OpaqueType::get());
4268 (yyval.TypeVal).S.makeSignless();
4273 #line 2046 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4274 { // Named types are also simple types...
4275 (yyval.TypeVal).S.copy(getTypeSign((yyvsp[0].ValIDVal)));
4276 const Type* tmp = getType((yyvsp[0].ValIDVal));
4277 (yyval.TypeVal).PAT = new PATypeHolder(tmp);
4282 #line 2051 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4283 { // Type UpReference
4284 if ((yyvsp[0].UInt64Val) > (uint64_t)~0U)
4285 error("Value out of range");
4286 OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder
4287 UpRefs.push_back(UpRefRecord((unsigned)(yyvsp[0].UInt64Val), OT)); // Add to vector...
4288 (yyval.TypeVal).PAT = new PATypeHolder(OT);
4289 (yyval.TypeVal).S.makeSignless();
4290 UR_OUT("New Upreference!\n");
4295 #line 2060 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4296 { // Function derived type?
4297 (yyval.TypeVal).S.makeComposite((yyvsp[-3].TypeVal).S);
4298 std::vector<const Type*> Params;
4299 for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-1].TypeList)->begin(),
4300 E = (yyvsp[-1].TypeList)->end(); I != E; ++I) {
4301 Params.push_back(I->PAT->get());
4302 (yyval.TypeVal).S.add(I->S);
4304 FunctionType::ParamAttrsList ParamAttrs;
4305 bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
4306 if (isVarArg) Params.pop_back();
4308 (yyval.TypeVal).PAT = new PATypeHolder(
4309 HandleUpRefs(FunctionType::get((yyvsp[-3].TypeVal).PAT->get(), Params, isVarArg,
4310 ParamAttrs), (yyval.TypeVal).S));
4311 delete (yyvsp[-3].TypeVal).PAT; // Delete the return type handle
4312 delete (yyvsp[-1].TypeList); // Delete the argument list
4317 #line 2078 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4318 { // Sized array type?
4319 (yyval.TypeVal).S.makeComposite((yyvsp[-1].TypeVal).S);
4320 (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(ArrayType::get((yyvsp[-1].TypeVal).PAT->get(),
4321 (unsigned)(yyvsp[-3].UInt64Val)), (yyval.TypeVal).S));
4322 delete (yyvsp[-1].TypeVal).PAT;
4327 #line 2084 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4329 const llvm::Type* ElemTy = (yyvsp[-1].TypeVal).PAT->get();
4330 if ((unsigned)(yyvsp[-3].UInt64Val) != (yyvsp[-3].UInt64Val))
4331 error("Unsigned result not equal to signed result");
4332 if (!(ElemTy->isInteger() || ElemTy->isFloatingPoint()))
4333 error("Elements of a VectorType must be integer or floating point");
4334 if (!isPowerOf2_32((yyvsp[-3].UInt64Val)))
4335 error("VectorType length should be a power of 2");
4336 (yyval.TypeVal).S.makeComposite((yyvsp[-1].TypeVal).S);
4337 (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(VectorType::get(ElemTy,
4338 (unsigned)(yyvsp[-3].UInt64Val)), (yyval.TypeVal).S));
4339 delete (yyvsp[-1].TypeVal).PAT;
4344 #line 2097 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4345 { // Structure type?
4346 std::vector<const Type*> Elements;
4347 (yyval.TypeVal).S.makeComposite();
4348 for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-1].TypeList)->begin(),
4349 E = (yyvsp[-1].TypeList)->end(); I != E; ++I) {
4350 Elements.push_back(I->PAT->get());
4351 (yyval.TypeVal).S.add(I->S);
4353 (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(StructType::get(Elements), (yyval.TypeVal).S));
4354 delete (yyvsp[-1].TypeList);
4359 #line 2108 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4360 { // Empty structure type?
4361 (yyval.TypeVal).PAT = new PATypeHolder(StructType::get(std::vector<const Type*>()));
4362 (yyval.TypeVal).S.makeComposite();
4367 #line 2112 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4368 { // Packed Structure type?
4369 (yyval.TypeVal).S.makeComposite();
4370 std::vector<const Type*> Elements;
4371 for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-2].TypeList)->begin(),
4372 E = (yyvsp[-2].TypeList)->end(); I != E; ++I) {
4373 Elements.push_back(I->PAT->get());
4374 (yyval.TypeVal).S.add(I->S);
4377 (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true),
4378 (yyval.TypeVal).S));
4379 delete (yyvsp[-2].TypeList);
4384 #line 2125 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4385 { // Empty packed structure type?
4386 (yyval.TypeVal).PAT = new PATypeHolder(StructType::get(std::vector<const Type*>(),true));
4387 (yyval.TypeVal).S.makeComposite();
4392 #line 2129 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4394 if ((yyvsp[-1].TypeVal).PAT->get() == Type::LabelTy)
4395 error("Cannot form a pointer to a basic block");
4396 (yyval.TypeVal).S.makeComposite((yyvsp[-1].TypeVal).S);
4397 (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(PointerType::get((yyvsp[-1].TypeVal).PAT->get()),
4398 (yyval.TypeVal).S));
4399 delete (yyvsp[-1].TypeVal).PAT;
4404 #line 2143 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4406 (yyval.TypeList) = new std::list<PATypeInfo>();
4407 (yyval.TypeList)->push_back((yyvsp[0].TypeVal));
4412 #line 2147 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4414 ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back((yyvsp[0].TypeVal));
4419 #line 2155 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4422 VoidTI.PAT = new PATypeHolder(Type::VoidTy);
4423 VoidTI.S.makeSignless();
4424 ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back(VoidTI);
4429 #line 2161 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4431 (yyval.TypeList) = new std::list<PATypeInfo>();
4433 VoidTI.PAT = new PATypeHolder(Type::VoidTy);
4434 VoidTI.S.makeSignless();
4435 (yyval.TypeList)->push_back(VoidTI);
4440 #line 2168 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4442 (yyval.TypeList) = new std::list<PATypeInfo>();
4447 #line 2180 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4448 { // Nonempty unsized arr
4449 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-3].TypeVal).PAT->get());
4451 error("Cannot make array constant with type: '" +
4452 (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'");
4453 const Type *ETy = ATy->getElementType();
4454 int NumElements = ATy->getNumElements();
4456 // Verify that we have the correct size...
4457 if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
4458 error("Type mismatch: constant sized array initialized with " +
4459 utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " +
4460 itostr(NumElements) + "");
4462 // Verify all elements are correct type!
4463 std::vector<Constant*> Elems;
4464 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
4465 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4466 const Type* ValTy = C->getType();
4468 error("Element #" + utostr(i) + " is not of type '" +
4469 ETy->getDescription() +"' as required!\nIt is of type '"+
4470 ValTy->getDescription() + "'");
4473 (yyval.ConstVal).C = ConstantArray::get(ATy, Elems);
4474 (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S);
4475 delete (yyvsp[-3].TypeVal).PAT;
4476 delete (yyvsp[-1].ConstVector);
4481 #line 2210 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4483 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-2].TypeVal).PAT->get());
4485 error("Cannot make array constant with type: '" +
4486 (yyvsp[-2].TypeVal).PAT->get()->getDescription() + "'");
4487 int NumElements = ATy->getNumElements();
4488 if (NumElements != -1 && NumElements != 0)
4489 error("Type mismatch: constant sized array initialized with 0"
4490 " arguments, but has size of " + itostr(NumElements) +"");
4491 (yyval.ConstVal).C = ConstantArray::get(ATy, std::vector<Constant*>());
4492 (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S);
4493 delete (yyvsp[-2].TypeVal).PAT;
4498 #line 2223 "/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 const Type *ETy = dyn_cast<IntegerType>(ATy->getElementType());
4506 if (!ETy || cast<IntegerType>(ETy)->getBitWidth() != 8)
4507 error("String arrays require type i8, not '" + ETy->getDescription() +
4509 char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
4510 if (NumElements != -1 && NumElements != (EndStr-(yyvsp[0].StrVal)))
4511 error("Can't build string constant of size " +
4512 itostr((int)(EndStr-(yyvsp[0].StrVal))) + " when array has size " +
4513 itostr(NumElements) + "");
4514 std::vector<Constant*> Vals;
4515 for (char *C = (char *)(yyvsp[0].StrVal); C != (char *)EndStr; ++C)
4516 Vals.push_back(ConstantInt::get(ETy, *C));
4517 free((yyvsp[0].StrVal));
4518 (yyval.ConstVal).C = ConstantArray::get(ATy, Vals);
4519 (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S);
4520 delete (yyvsp[-2].TypeVal).PAT;
4525 #line 2246 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4526 { // Nonempty unsized arr
4527 const VectorType *PTy = dyn_cast<VectorType>((yyvsp[-3].TypeVal).PAT->get());
4529 error("Cannot make packed constant with type: '" +
4530 (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'");
4531 const Type *ETy = PTy->getElementType();
4532 int NumElements = PTy->getNumElements();
4533 // Verify that we have the correct size...
4534 if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
4535 error("Type mismatch: constant sized packed initialized with " +
4536 utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " +
4537 itostr(NumElements) + "");
4538 // Verify all elements are correct type!
4539 std::vector<Constant*> Elems;
4540 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
4541 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4542 const Type* ValTy = C->getType();
4544 error("Element #" + utostr(i) + " is not of type '" +
4545 ETy->getDescription() +"' as required!\nIt is of type '"+
4546 ValTy->getDescription() + "'");
4549 (yyval.ConstVal).C = ConstantVector::get(PTy, Elems);
4550 (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S);
4551 delete (yyvsp[-3].TypeVal).PAT;
4552 delete (yyvsp[-1].ConstVector);
4557 #line 2274 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4559 const StructType *STy = dyn_cast<StructType>((yyvsp[-3].TypeVal).PAT->get());
4561 error("Cannot make struct constant with type: '" +
4562 (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'");
4563 if ((yyvsp[-1].ConstVector)->size() != STy->getNumContainedTypes())
4564 error("Illegal number of initializers for structure type");
4566 // Check to ensure that constants are compatible with the type initializer!
4567 std::vector<Constant*> Fields;
4568 for (unsigned i = 0, e = (yyvsp[-1].ConstVector)->size(); i != e; ++i) {
4569 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4570 if (C->getType() != STy->getElementType(i))
4571 error("Expected type '" + STy->getElementType(i)->getDescription() +
4572 "' for element #" + utostr(i) + " of structure initializer");
4573 Fields.push_back(C);
4575 (yyval.ConstVal).C = ConstantStruct::get(STy, Fields);
4576 (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S);
4577 delete (yyvsp[-3].TypeVal).PAT;
4578 delete (yyvsp[-1].ConstVector);
4583 #line 2296 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4585 const StructType *STy = dyn_cast<StructType>((yyvsp[-2].TypeVal).PAT->get());
4587 error("Cannot make struct constant with type: '" +
4588 (yyvsp[-2].TypeVal).PAT->get()->getDescription() + "'");
4589 if (STy->getNumContainedTypes() != 0)
4590 error("Illegal number of initializers for structure type");
4591 (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector<Constant*>());
4592 (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S);
4593 delete (yyvsp[-2].TypeVal).PAT;
4598 #line 2307 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4600 const StructType *STy = dyn_cast<StructType>((yyvsp[-5].TypeVal).PAT->get());
4602 error("Cannot make packed struct constant with type: '" +
4603 (yyvsp[-5].TypeVal).PAT->get()->getDescription() + "'");
4604 if ((yyvsp[-2].ConstVector)->size() != STy->getNumContainedTypes())
4605 error("Illegal number of initializers for packed structure type");
4607 // Check to ensure that constants are compatible with the type initializer!
4608 std::vector<Constant*> Fields;
4609 for (unsigned i = 0, e = (yyvsp[-2].ConstVector)->size(); i != e; ++i) {
4610 Constant *C = (*(yyvsp[-2].ConstVector))[i].C;
4611 if (C->getType() != STy->getElementType(i))
4612 error("Expected type '" + STy->getElementType(i)->getDescription() +
4613 "' for element #" + utostr(i) + " of packed struct initializer");
4614 Fields.push_back(C);
4616 (yyval.ConstVal).C = ConstantStruct::get(STy, Fields);
4617 (yyval.ConstVal).S.copy((yyvsp[-5].TypeVal).S);
4618 delete (yyvsp[-5].TypeVal).PAT;
4619 delete (yyvsp[-2].ConstVector);
4624 #line 2329 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4626 const StructType *STy = dyn_cast<StructType>((yyvsp[-4].TypeVal).PAT->get());
4628 error("Cannot make packed struct constant with type: '" +
4629 (yyvsp[-4].TypeVal).PAT->get()->getDescription() + "'");
4630 if (STy->getNumContainedTypes() != 0)
4631 error("Illegal number of initializers for packed structure type");
4632 (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector<Constant*>());
4633 (yyval.ConstVal).S.copy((yyvsp[-4].TypeVal).S);
4634 delete (yyvsp[-4].TypeVal).PAT;
4639 #line 2340 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4641 const PointerType *PTy = dyn_cast<PointerType>((yyvsp[-1].TypeVal).PAT->get());
4643 error("Cannot make null pointer constant with type: '" +
4644 (yyvsp[-1].TypeVal).PAT->get()->getDescription() + "'");
4645 (yyval.ConstVal).C = ConstantPointerNull::get(PTy);
4646 (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
4647 delete (yyvsp[-1].TypeVal).PAT;
4652 #line 2349 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4654 (yyval.ConstVal).C = UndefValue::get((yyvsp[-1].TypeVal).PAT->get());
4655 (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
4656 delete (yyvsp[-1].TypeVal).PAT;
4661 #line 2354 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4663 const PointerType *Ty = dyn_cast<PointerType>((yyvsp[-1].TypeVal).PAT->get());
4665 error("Global const reference must be a pointer type, not" +
4666 (yyvsp[-1].TypeVal).PAT->get()->getDescription());
4668 // ConstExprs can exist in the body of a function, thus creating
4669 // GlobalValues whenever they refer to a variable. Because we are in
4670 // the context of a function, getExistingValue will search the functions
4671 // symbol table instead of the module symbol table for the global symbol,
4672 // which throws things all off. To get around this, we just tell
4673 // getExistingValue that we are at global scope here.
4675 Function *SavedCurFn = CurFun.CurrentFunction;
4676 CurFun.CurrentFunction = 0;
4677 (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S);
4678 Value *V = getExistingValue(Ty, (yyvsp[0].ValIDVal));
4679 CurFun.CurrentFunction = SavedCurFn;
4681 // If this is an initializer for a constant pointer, which is referencing a
4682 // (currently) undefined variable, create a stub now that shall be replaced
4683 // in the future with the right type of variable.
4686 assert(isa<PointerType>(Ty) && "Globals may only be used as pointers");
4687 const PointerType *PT = cast<PointerType>(Ty);
4689 // First check to see if the forward references value is already created!
4690 PerModuleInfo::GlobalRefsType::iterator I =
4691 CurModule.GlobalRefs.find(std::make_pair(PT, (yyvsp[0].ValIDVal)));
4693 if (I != CurModule.GlobalRefs.end()) {
4694 V = I->second; // Placeholder already exists, use it...
4695 (yyvsp[0].ValIDVal).destroy();
4698 if ((yyvsp[0].ValIDVal).Type == ValID::NameVal) Name = (yyvsp[0].ValIDVal).Name;
4700 // Create the forward referenced global.
4702 if (const FunctionType *FTy =
4703 dyn_cast<FunctionType>(PT->getElementType())) {
4704 GV = new Function(FTy, GlobalValue::ExternalLinkage, Name,
4705 CurModule.CurrentModule);
4707 GV = new GlobalVariable(PT->getElementType(), false,
4708 GlobalValue::ExternalLinkage, 0,
4709 Name, CurModule.CurrentModule);
4712 // Keep track of the fact that we have a forward ref to recycle it
4713 CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, (yyvsp[0].ValIDVal)), GV));
4717 (yyval.ConstVal).C = cast<GlobalValue>(V);
4718 (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
4719 delete (yyvsp[-1].TypeVal).PAT; // Free the type handle
4724 #line 2413 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4726 if ((yyvsp[-1].TypeVal).PAT->get() != (yyvsp[0].ConstVal).C->getType())
4727 error("Mismatched types for constant expression");
4728 (yyval.ConstVal) = (yyvsp[0].ConstVal);
4729 (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
4730 delete (yyvsp[-1].TypeVal).PAT;
4735 #line 2420 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4737 const Type *Ty = (yyvsp[-1].TypeVal).PAT->get();
4738 if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty))
4739 error("Cannot create a null initialized value of this type");
4740 (yyval.ConstVal).C = Constant::getNullValue(Ty);
4741 (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
4742 delete (yyvsp[-1].TypeVal).PAT;
4747 #line 2428 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4748 { // integral constants
4749 const Type *Ty = (yyvsp[-1].PrimType).T;
4750 if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].SInt64Val)))
4751 error("Constant value doesn't fit in type");
4752 (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].SInt64Val));
4753 (yyval.ConstVal).S.makeSigned();
4758 #line 2435 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4759 { // integral constants
4760 const Type *Ty = (yyvsp[-1].PrimType).T;
4761 if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].UInt64Val)))
4762 error("Constant value doesn't fit in type");
4763 (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].UInt64Val));
4764 (yyval.ConstVal).S.makeUnsigned();
4769 #line 2442 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4770 { // Boolean constants
4771 (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, true);
4772 (yyval.ConstVal).S.makeUnsigned();
4777 #line 2446 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4778 { // Boolean constants
4779 (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, false);
4780 (yyval.ConstVal).S.makeUnsigned();
4785 #line 2450 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4786 { // Float & Double constants
4787 if (!ConstantFP::isValueValidForType((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal)))
4788 error("Floating point constant invalid for type");
4789 (yyval.ConstVal).C = ConstantFP::get((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal));
4790 (yyval.ConstVal).S.makeSignless();
4795 #line 2459 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4797 const Type* SrcTy = (yyvsp[-3].ConstVal).C->getType();
4798 const Type* DstTy = (yyvsp[-1].TypeVal).PAT->get();
4799 Signedness SrcSign((yyvsp[-3].ConstVal).S);
4800 Signedness DstSign((yyvsp[-1].TypeVal).S);
4801 if (!SrcTy->isFirstClassType())
4802 error("cast constant expression from a non-primitive type: '" +
4803 SrcTy->getDescription() + "'");
4804 if (!DstTy->isFirstClassType())
4805 error("cast constant expression to a non-primitive type: '" +
4806 DstTy->getDescription() + "'");
4807 (yyval.ConstVal).C = cast<Constant>(getCast((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal).C, SrcSign, DstTy, DstSign));
4808 (yyval.ConstVal).S.copy(DstSign);
4809 delete (yyvsp[-1].TypeVal).PAT;
4814 #line 2474 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4816 const Type *Ty = (yyvsp[-2].ConstVal).C->getType();
4817 if (!isa<PointerType>(Ty))
4818 error("GetElementPtr requires a pointer operand");
4820 std::vector<Value*> VIndices;
4821 std::vector<Constant*> CIndices;
4822 upgradeGEPIndices((yyvsp[-2].ConstVal).C->getType(), (yyvsp[-1].ValueList), VIndices, &CIndices);
4824 delete (yyvsp[-1].ValueList);
4825 (yyval.ConstVal).C = ConstantExpr::getGetElementPtr((yyvsp[-2].ConstVal).C, &CIndices[0], CIndices.size());
4826 (yyval.ConstVal).S.copy(getElementSign((yyvsp[-2].ConstVal), CIndices));
4831 #line 2487 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4833 if (!(yyvsp[-5].ConstVal).C->getType()->isInteger() ||
4834 cast<IntegerType>((yyvsp[-5].ConstVal).C->getType())->getBitWidth() != 1)
4835 error("Select condition must be bool type");
4836 if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4837 error("Select operand types must match");
4838 (yyval.ConstVal).C = ConstantExpr::getSelect((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4839 (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S);
4844 #line 2496 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4846 const Type *Ty = (yyvsp[-3].ConstVal).C->getType();
4847 if (Ty != (yyvsp[-1].ConstVal).C->getType())
4848 error("Binary operator types must match");
4849 // First, make sure we're dealing with the right opcode by upgrading from
4850 // obsolete versions.
4851 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S);
4853 // HACK: llvm 1.3 and earlier used to emit invalid pointer constant exprs.
4854 // To retain backward compatibility with these early compilers, we emit a
4855 // cast to the appropriate integer type automatically if we are in the
4856 // broken case. See PR424 for more information.
4857 if (!isa<PointerType>(Ty)) {
4858 (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4860 const Type *IntPtrTy = 0;
4861 switch (CurModule.CurrentModule->getPointerSize()) {
4862 case Module::Pointer32: IntPtrTy = Type::Int32Ty; break;
4863 case Module::Pointer64: IntPtrTy = Type::Int64Ty; break;
4864 default: error("invalid pointer binary constant expr");
4866 (yyval.ConstVal).C = ConstantExpr::get(Opcode,
4867 ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-3].ConstVal).C, IntPtrTy),
4868 ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-1].ConstVal).C, IntPtrTy));
4869 (yyval.ConstVal).C = ConstantExpr::getCast(Instruction::IntToPtr, (yyval.ConstVal).C, Ty);
4871 (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S);
4876 #line 2524 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4878 const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4879 if (Ty != (yyvsp[-1].ConstVal).C->getType())
4880 error("Logical operator types must match");
4881 if (!Ty->isInteger()) {
4882 if (!isa<VectorType>(Ty) ||
4883 !cast<VectorType>(Ty)->getElementType()->isInteger())
4884 error("Logical operator requires integer operands");
4886 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S);
4887 (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4888 (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S);
4893 #line 2537 "/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("setcc operand types must match");
4898 unsigned short pred;
4899 Instruction::OtherOps Opcode = getCompareOp((yyvsp[-5].BinaryOpVal), pred, Ty, (yyvsp[-3].ConstVal).S);
4900 (yyval.ConstVal).C = ConstantExpr::getCompare(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4901 (yyval.ConstVal).S.makeUnsigned();
4906 #line 2546 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4908 if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4909 error("icmp operand types must match");
4910 (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].IPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4911 (yyval.ConstVal).S.makeUnsigned();
4916 #line 2552 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4918 if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4919 error("fcmp operand types must match");
4920 (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].FPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4921 (yyval.ConstVal).S.makeUnsigned();
4926 #line 2558 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4928 if (!(yyvsp[-1].ConstVal).C->getType()->isInteger() ||
4929 cast<IntegerType>((yyvsp[-1].ConstVal).C->getType())->getBitWidth() != 8)
4930 error("Shift count for shift constant must be unsigned byte");
4931 const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4932 if (!(yyvsp[-3].ConstVal).C->getType()->isInteger())
4933 error("Shift constant expression requires integer operand");
4934 Constant *ShiftAmt = ConstantExpr::getZExt((yyvsp[-1].ConstVal).C, Ty);
4935 (yyval.ConstVal).C = ConstantExpr::get(getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S), (yyvsp[-3].ConstVal).C, ShiftAmt);
4936 (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S);
4941 #line 2569 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4943 if (!ExtractElementInst::isValidOperands((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4944 error("Invalid extractelement operands");
4945 (yyval.ConstVal).C = ConstantExpr::getExtractElement((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4946 (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S.get(0));
4951 #line 2575 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4953 if (!InsertElementInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4954 error("Invalid insertelement operands");
4955 (yyval.ConstVal).C = ConstantExpr::getInsertElement((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4956 (yyval.ConstVal).S.copy((yyvsp[-5].ConstVal).S);
4961 #line 2581 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4963 if (!ShuffleVectorInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4964 error("Invalid shufflevector operands");
4965 (yyval.ConstVal).C = ConstantExpr::getShuffleVector((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4966 (yyval.ConstVal).S.copy((yyvsp[-5].ConstVal).S);
4971 #line 2592 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4972 { ((yyval.ConstVector) = (yyvsp[-2].ConstVector))->push_back((yyvsp[0].ConstVal)); ;}
4976 #line 2593 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4978 (yyval.ConstVector) = new std::vector<ConstInfo>();
4979 (yyval.ConstVector)->push_back((yyvsp[0].ConstVal));
4984 #line 2602 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4985 { (yyval.BoolVal) = false; ;}
4989 #line 2603 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4990 { (yyval.BoolVal) = true; ;}
4994 #line 2615 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4996 (yyval.ModuleVal) = ParserResult = (yyvsp[0].ModuleVal);
4997 CurModule.ModuleDone();
5002 #line 2624 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5003 { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); CurFun.FunctionDone(); ;}
5007 #line 2625 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5008 { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;}
5012 #line 2626 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5013 { (yyval.ModuleVal) = (yyvsp[-3].ModuleVal); ;}
5017 #line 2627 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5018 { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;}
5022 #line 2628 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5024 (yyval.ModuleVal) = CurModule.CurrentModule;
5025 // Emit an error if there are any unresolved types left.
5026 if (!CurModule.LateResolveTypes.empty()) {
5027 const ValID &DID = CurModule.LateResolveTypes.begin()->first;
5028 if (DID.Type == ValID::NameVal) {
5029 error("Reference to an undefined type: '"+DID.getName() + "'");
5031 error("Reference to an undefined type: #" + itostr(DID.Num));
5038 #line 2644 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5040 // Eagerly resolve types. This is not an optimization, this is a
5041 // requirement that is due to the fact that we could have this:
5043 // %list = type { %list * }
5044 // %list = type { %list * } ; repeated type decl
5046 // If types are not resolved eagerly, then the two types will not be
5047 // determined to be the same type!
5049 ResolveTypeTo((yyvsp[-2].StrVal), (yyvsp[0].TypeVal).PAT->get(), (yyvsp[0].TypeVal).S);
5051 if (!setTypeName((yyvsp[0].TypeVal), (yyvsp[-2].StrVal)) && !(yyvsp[-2].StrVal)) {
5052 // If this is a numbered type that is not a redefinition, add it to the
5054 CurModule.Types.push_back((yyvsp[0].TypeVal).PAT->get());
5055 CurModule.TypeSigns.push_back((yyvsp[0].TypeVal).S);
5057 delete (yyvsp[0].TypeVal).PAT;
5062 #line 2664 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5063 { // Function prototypes can be in const pool
5068 #line 2666 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5069 { // Asm blocks can be in the const pool
5074 #line 2668 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5076 if ((yyvsp[0].ConstVal).C == 0)
5077 error("Global value initializer is not a constant");
5078 CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), (yyvsp[-2].Linkage), (yyvsp[-1].BoolVal), (yyvsp[0].ConstVal).C->getType(), (yyvsp[0].ConstVal).C, (yyvsp[0].ConstVal).S);
5083 #line 2672 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5090 #line 2675 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5092 const Type *Ty = (yyvsp[0].TypeVal).PAT->get();
5093 CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalLinkage, (yyvsp[-1].BoolVal), Ty, 0,
5094 (yyvsp[0].TypeVal).S);
5095 delete (yyvsp[0].TypeVal).PAT;
5100 #line 2680 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5107 #line 2683 "/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::DLLImportLinkage, (yyvsp[-1].BoolVal), Ty, 0,
5111 (yyvsp[0].TypeVal).S);
5112 delete (yyvsp[0].TypeVal).PAT;
5117 #line 2688 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5124 #line 2691 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5126 const Type *Ty = (yyvsp[0].TypeVal).PAT->get();
5128 ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalWeakLinkage, (yyvsp[-1].BoolVal), Ty, 0,
5129 (yyvsp[0].TypeVal).S);
5130 delete (yyvsp[0].TypeVal).PAT;
5135 #line 2697 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5142 #line 2700 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5148 #line 2702 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5154 #line 2704 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5160 #line 2709 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5162 const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
5163 char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
5164 std::string NewAsm((yyvsp[0].StrVal), EndStr);
5165 free((yyvsp[0].StrVal));
5167 if (AsmSoFar.empty())
5168 CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
5170 CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
5175 #line 2723 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5176 { (yyval.Endianness) = Module::BigEndian; ;}
5180 #line 2724 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5181 { (yyval.Endianness) = Module::LittleEndian; ;}
5185 #line 2728 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5187 CurModule.setEndianness((yyvsp[0].Endianness));
5192 #line 2731 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5194 if ((yyvsp[0].UInt64Val) == 32)
5195 CurModule.setPointerSize(Module::Pointer32);
5196 else if ((yyvsp[0].UInt64Val) == 64)
5197 CurModule.setPointerSize(Module::Pointer64);
5199 error("Invalid pointer size: '" + utostr((yyvsp[0].UInt64Val)) + "'");
5204 #line 2739 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5206 CurModule.CurrentModule->setTargetTriple((yyvsp[0].StrVal));
5207 free((yyvsp[0].StrVal));
5212 #line 2743 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5214 CurModule.CurrentModule->setDataLayout((yyvsp[0].StrVal));
5215 free((yyvsp[0].StrVal));
5220 #line 2754 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5222 CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
5223 free((yyvsp[0].StrVal));
5228 #line 2758 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5230 CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
5231 free((yyvsp[0].StrVal));
5236 #line 2762 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5241 #line 2775 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5242 { (yyval.StrVal) = 0; ;}
5246 #line 2779 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5248 if ((yyvsp[-1].TypeVal).PAT->get() == Type::VoidTy)
5249 error("void typed arguments are invalid");
5250 (yyval.ArgVal) = new std::pair<PATypeInfo, char*>((yyvsp[-1].TypeVal), (yyvsp[0].StrVal));
5255 #line 2787 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5257 (yyval.ArgList) = (yyvsp[-2].ArgList);
5258 (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal));
5259 delete (yyvsp[0].ArgVal);
5264 #line 2792 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5266 (yyval.ArgList) = new std::vector<std::pair<PATypeInfo,char*> >();
5267 (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal));
5268 delete (yyvsp[0].ArgVal);
5273 #line 2800 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5274 { (yyval.ArgList) = (yyvsp[0].ArgList); ;}
5278 #line 2801 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5280 (yyval.ArgList) = (yyvsp[-2].ArgList);
5282 VoidTI.PAT = new PATypeHolder(Type::VoidTy);
5283 VoidTI.S.makeSignless();
5284 (yyval.ArgList)->push_back(std::pair<PATypeInfo, char*>(VoidTI, 0));
5289 #line 2808 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5291 (yyval.ArgList) = new std::vector<std::pair<PATypeInfo,char*> >();
5293 VoidTI.PAT = new PATypeHolder(Type::VoidTy);
5294 VoidTI.S.makeSignless();
5295 (yyval.ArgList)->push_back(std::pair<PATypeInfo, char*>(VoidTI, 0));
5300 #line 2815 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5301 { (yyval.ArgList) = 0; ;}
5305 #line 2819 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5307 UnEscapeLexed((yyvsp[-5].StrVal));
5308 std::string FunctionName((yyvsp[-5].StrVal));
5309 free((yyvsp[-5].StrVal)); // Free strdup'd memory!
5311 const Type* RetTy = (yyvsp[-6].TypeVal).PAT->get();
5313 if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
5314 error("LLVM functions cannot return aggregate types");
5317 FTySign.makeComposite((yyvsp[-6].TypeVal).S);
5318 std::vector<const Type*> ParamTyList;
5320 // In LLVM 2.0 the signatures of three varargs intrinsics changed to take
5321 // i8*. We check here for those names and override the parameter list
5322 // types to ensure the prototype is correct.
5323 if (FunctionName == "llvm.va_start" || FunctionName == "llvm.va_end") {
5324 ParamTyList.push_back(PointerType::get(Type::Int8Ty));
5325 } else if (FunctionName == "llvm.va_copy") {
5326 ParamTyList.push_back(PointerType::get(Type::Int8Ty));
5327 ParamTyList.push_back(PointerType::get(Type::Int8Ty));
5328 } else if ((yyvsp[-3].ArgList)) { // If there are arguments...
5329 for (std::vector<std::pair<PATypeInfo,char*> >::iterator
5330 I = (yyvsp[-3].ArgList)->begin(), E = (yyvsp[-3].ArgList)->end(); I != E; ++I) {
5331 const Type *Ty = I->first.PAT->get();
5332 ParamTyList.push_back(Ty);
5333 FTySign.add(I->first.S);
5337 bool isVarArg = ParamTyList.size() && ParamTyList.back() == Type::VoidTy;
5339 ParamTyList.pop_back();
5341 // Convert the CSRet calling convention into the corresponding parameter
5343 FunctionType::ParamAttrsList ParamAttrs;
5344 if ((yyvsp[-7].UIntVal) == OldCallingConv::CSRet) {
5345 ParamAttrs.push_back(FunctionType::NoAttributeSet); // result
5346 ParamAttrs.push_back(FunctionType::StructRetAttribute); // first arg
5349 const FunctionType *FT = FunctionType::get(RetTy, ParamTyList, isVarArg,
5351 const PointerType *PFT = PointerType::get(FT);
5352 delete (yyvsp[-6].TypeVal).PAT;
5355 if (!FunctionName.empty()) {
5356 ID = ValID::create((char*)FunctionName.c_str());
5358 ID = ValID::create((int)CurModule.Values[PFT].size());
5360 ID.S.makeComposite(FTySign);
5363 Module* M = CurModule.CurrentModule;
5365 // See if this function was forward referenced. If so, recycle the object.
5366 if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
5367 // Move the function to the end of the list, from whereever it was
5368 // previously inserted.
5369 Fn = cast<Function>(FWRef);
5370 M->getFunctionList().remove(Fn);
5371 M->getFunctionList().push_back(Fn);
5372 } else if (!FunctionName.empty()) {
5373 GlobalValue *Conflict = M->getFunction(FunctionName);
5375 Conflict = M->getNamedGlobal(FunctionName);
5376 if (Conflict && PFT == Conflict->getType()) {
5377 if (!CurFun.isDeclare && !Conflict->isDeclaration()) {
5378 // We have two function definitions that conflict, same type, same
5379 // name. We should really check to make sure that this is the result
5380 // of integer type planes collapsing and generate an error if it is
5381 // not, but we'll just rename on the assumption that it is. However,
5382 // let's do it intelligently and rename the internal linkage one
5384 std::string NewName(makeNameUnique(FunctionName));
5385 if (Conflict->hasInternalLinkage()) {
5386 Conflict->setName(NewName);
5388 makeRenameMapKey(FunctionName, Conflict->getType(), ID.S);
5389 CurModule.RenameMap[Key] = NewName;
5390 Fn = new Function(FT, CurFun.Linkage, FunctionName, M);
5391 InsertValue(Fn, CurModule.Values);
5393 Fn = new Function(FT, CurFun.Linkage, NewName, M);
5394 InsertValue(Fn, CurModule.Values);
5396 makeRenameMapKey(FunctionName, PFT, ID.S);
5397 CurModule.RenameMap[Key] = NewName;
5400 // If they are not both definitions, then just use the function we
5401 // found since the types are the same.
5402 Fn = cast<Function>(Conflict);
5404 // Make sure to strip off any argument names so we can't get
5406 if (Fn->isDeclaration())
5407 for (Function::arg_iterator AI = Fn->arg_begin(),
5408 AE = Fn->arg_end(); AI != AE; ++AI)
5411 } else if (Conflict) {
5412 // We have two globals with the same name and different types.
5413 // Previously, this was permitted because the symbol table had
5414 // "type planes" and names only needed to be distinct within a
5415 // type plane. After PR411 was fixed, this is no loner the case.
5416 // To resolve this we must rename one of the two.
5417 if (Conflict->hasInternalLinkage()) {
5418 // We can safely rename the Conflict.
5420 makeRenameMapKey(Conflict->getName(), Conflict->getType(),
5421 CurModule.NamedValueSigns[Conflict->getName()]);
5422 Conflict->setName(makeNameUnique(Conflict->getName()));
5423 CurModule.RenameMap[Key] = Conflict->getName();
5424 Fn = new Function(FT, CurFun.Linkage, FunctionName, M);
5425 InsertValue(Fn, CurModule.Values);
5427 // We can't quietly rename either of these things, but we must
5428 // rename one of them. Only if the function's linkage is internal can
5429 // we forgo a warning message about the renamed function.
5430 std::string NewName = makeNameUnique(FunctionName);
5431 if (CurFun.Linkage != GlobalValue::InternalLinkage) {
5432 warning("Renaming function '" + FunctionName + "' as '" + NewName +
5433 "' may cause linkage errors");
5435 // Elect to rename the thing we're now defining.
5436 Fn = new Function(FT, CurFun.Linkage, NewName, M);
5437 InsertValue(Fn, CurModule.Values);
5438 RenameMapKey Key = makeRenameMapKey(FunctionName, PFT, ID.S);
5439 CurModule.RenameMap[Key] = NewName;
5442 // There's no conflict, just define the function
5443 Fn = new Function(FT, CurFun.Linkage, FunctionName, M);
5444 InsertValue(Fn, CurModule.Values);
5448 CurFun.FunctionStart(Fn);
5450 if (CurFun.isDeclare) {
5451 // If we have declaration, always overwrite linkage. This will allow us
5452 // to correctly handle cases, when pointer to function is passed as
5453 // argument to another function.
5454 Fn->setLinkage(CurFun.Linkage);
5456 Fn->setCallingConv(upgradeCallingConv((yyvsp[-7].UIntVal)));
5457 Fn->setAlignment((yyvsp[0].UIntVal));
5458 if ((yyvsp[-1].StrVal)) {
5459 Fn->setSection((yyvsp[-1].StrVal));
5460 free((yyvsp[-1].StrVal));
5463 // Add all of the arguments we parsed to the function...
5464 if ((yyvsp[-3].ArgList)) { // Is null if empty...
5465 if (isVarArg) { // Nuke the last entry
5466 assert((yyvsp[-3].ArgList)->back().first.PAT->get() == Type::VoidTy &&
5467 (yyvsp[-3].ArgList)->back().second == 0 && "Not a varargs marker");
5468 delete (yyvsp[-3].ArgList)->back().first.PAT;
5469 (yyvsp[-3].ArgList)->pop_back(); // Delete the last entry
5471 Function::arg_iterator ArgIt = Fn->arg_begin();
5472 Function::arg_iterator ArgEnd = Fn->arg_end();
5473 std::vector<std::pair<PATypeInfo,char*> >::iterator I = (yyvsp[-3].ArgList)->begin();
5474 std::vector<std::pair<PATypeInfo,char*> >::iterator E = (yyvsp[-3].ArgList)->end();
5475 for ( ; I != E && ArgIt != ArgEnd; ++I, ++ArgIt) {
5476 delete I->first.PAT; // Delete the typeholder...
5477 ValueInfo VI; VI.V = ArgIt; VI.S.copy(I->first.S);
5478 setValueName(VI, I->second); // Insert arg into symtab...
5481 delete (yyvsp[-3].ArgList); // We're now done with the argument list
5487 #line 3004 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5488 { CurFun.Linkage = (yyvsp[0].Linkage); ;}
5492 #line 3004 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5494 (yyval.FunctionVal) = CurFun.CurrentFunction;
5496 // Make sure that we keep track of the linkage type even if there was a
5497 // previous "declare".
5498 (yyval.FunctionVal)->setLinkage((yyvsp[-3].Linkage));
5503 #line 3018 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5505 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5510 #line 3023 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5511 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
5515 #line 3024 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5516 { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
5520 #line 3025 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5521 { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
5525 #line 3029 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5526 { CurFun.isDeclare = true; ;}
5530 #line 3030 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5531 { CurFun.Linkage = (yyvsp[0].Linkage); ;}
5535 #line 3030 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5537 (yyval.FunctionVal) = CurFun.CurrentFunction;
5538 CurFun.FunctionDone();
5544 #line 3042 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5545 { (yyval.BoolVal) = false; ;}
5549 #line 3043 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5550 { (yyval.BoolVal) = true; ;}
5554 #line 3048 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5555 { (yyval.ValIDVal) = ValID::create((yyvsp[0].SInt64Val)); ;}
5559 #line 3049 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5560 { (yyval.ValIDVal) = ValID::create((yyvsp[0].UInt64Val)); ;}
5564 #line 3050 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5565 { (yyval.ValIDVal) = ValID::create((yyvsp[0].FPVal)); ;}
5569 #line 3051 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5571 (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, true));
5572 (yyval.ValIDVal).S.makeUnsigned();
5577 #line 3055 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5579 (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, false));
5580 (yyval.ValIDVal).S.makeUnsigned();
5585 #line 3059 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5586 { (yyval.ValIDVal) = ValID::createNull(); ;}
5590 #line 3060 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5591 { (yyval.ValIDVal) = ValID::createUndef(); ;}
5595 #line 3061 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5596 { (yyval.ValIDVal) = ValID::createZeroInit(); ;}
5600 #line 3062 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5601 { // Nonempty unsized packed vector
5602 const Type *ETy = (*(yyvsp[-1].ConstVector))[0].C->getType();
5603 int NumElements = (yyvsp[-1].ConstVector)->size();
5604 VectorType* pt = VectorType::get(ETy, NumElements);
5605 (yyval.ValIDVal).S.makeComposite((*(yyvsp[-1].ConstVector))[0].S);
5606 PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(pt, (yyval.ValIDVal).S));
5608 // Verify all elements are correct type!
5609 std::vector<Constant*> Elems;
5610 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
5611 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
5612 const Type *CTy = C->getType();
5614 error("Element #" + utostr(i) + " is not of type '" +
5615 ETy->getDescription() +"' as required!\nIt is of type '" +
5616 CTy->getDescription() + "'");
5619 (yyval.ValIDVal) = ValID::create(ConstantVector::get(pt, Elems));
5620 delete PTy; delete (yyvsp[-1].ConstVector);
5625 #line 3083 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5627 (yyval.ValIDVal) = ValID::create((yyvsp[0].ConstVal).C);
5628 (yyval.ValIDVal).S.copy((yyvsp[0].ConstVal).S);
5633 #line 3087 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5635 char *End = UnEscapeLexed((yyvsp[-2].StrVal), true);
5636 std::string AsmStr = std::string((yyvsp[-2].StrVal), End);
5637 End = UnEscapeLexed((yyvsp[0].StrVal), true);
5638 std::string Constraints = std::string((yyvsp[0].StrVal), End);
5639 (yyval.ValIDVal) = ValID::createInlineAsm(AsmStr, Constraints, (yyvsp[-3].BoolVal));
5640 free((yyvsp[-2].StrVal));
5641 free((yyvsp[0].StrVal));
5646 #line 3101 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5647 { (yyval.ValIDVal) = ValID::create((yyvsp[0].SIntVal)); (yyval.ValIDVal).S.makeSignless(); ;}
5651 #line 3102 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5652 { (yyval.ValIDVal) = ValID::create((yyvsp[0].StrVal)); (yyval.ValIDVal).S.makeSignless(); ;}
5656 #line 3115 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5658 const Type *Ty = (yyvsp[-1].TypeVal).PAT->get();
5659 (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S);
5660 (yyval.ValueVal).V = getVal(Ty, (yyvsp[0].ValIDVal));
5661 (yyval.ValueVal).S.copy((yyvsp[-1].TypeVal).S);
5662 delete (yyvsp[-1].TypeVal).PAT;
5667 #line 3125 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5669 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5674 #line 3128 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5675 { // Do not allow functions with 0 basic blocks
5676 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5681 #line 3137 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5683 ValueInfo VI; VI.V = (yyvsp[0].TermInstVal).TI; VI.S.copy((yyvsp[0].TermInstVal).S);
5684 setValueName(VI, (yyvsp[-1].StrVal));
5685 InsertValue((yyvsp[0].TermInstVal).TI);
5686 (yyvsp[-2].BasicBlockVal)->getInstList().push_back((yyvsp[0].TermInstVal).TI);
5687 InsertValue((yyvsp[-2].BasicBlockVal));
5688 (yyval.BasicBlockVal) = (yyvsp[-2].BasicBlockVal);
5693 #line 3148 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5695 if ((yyvsp[0].InstVal).I)
5696 (yyvsp[-1].BasicBlockVal)->getInstList().push_back((yyvsp[0].InstVal).I);
5697 (yyval.BasicBlockVal) = (yyvsp[-1].BasicBlockVal);
5702 #line 3153 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5704 (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++),true);
5705 // Make sure to move the basic block to the correct location in the
5706 // function, instead of leaving it inserted wherever it was first
5708 Function::BasicBlockListType &BBL =
5709 CurFun.CurrentFunction->getBasicBlockList();
5710 BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
5715 #line 3162 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5717 (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((yyvsp[0].StrVal)), true);
5718 // Make sure to move the basic block to the correct location in the
5719 // function, instead of leaving it inserted wherever it was first
5721 Function::BasicBlockListType &BBL =
5722 CurFun.CurrentFunction->getBasicBlockList();
5723 BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
5728 #line 3176 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5729 { // Return with a result...
5730 (yyval.TermInstVal).TI = new ReturnInst((yyvsp[0].ValueVal).V);
5731 (yyval.TermInstVal).S.makeSignless();
5736 #line 3180 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5737 { // Return with no result...
5738 (yyval.TermInstVal).TI = new ReturnInst();
5739 (yyval.TermInstVal).S.makeSignless();
5744 #line 3184 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5745 { // Unconditional Branch...
5746 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5747 (yyval.TermInstVal).TI = new BranchInst(tmpBB);
5748 (yyval.TermInstVal).S.makeSignless();
5753 #line 3189 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5755 (yyvsp[-3].ValIDVal).S.makeSignless();
5756 (yyvsp[0].ValIDVal).S.makeSignless();
5757 BasicBlock* tmpBBA = getBBVal((yyvsp[-3].ValIDVal));
5758 BasicBlock* tmpBBB = getBBVal((yyvsp[0].ValIDVal));
5759 (yyvsp[-6].ValIDVal).S.makeUnsigned();
5760 Value* tmpVal = getVal(Type::Int1Ty, (yyvsp[-6].ValIDVal));
5761 (yyval.TermInstVal).TI = new BranchInst(tmpBBA, tmpBBB, tmpVal);
5762 (yyval.TermInstVal).S.makeSignless();
5767 #line 3199 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5769 (yyvsp[-6].ValIDVal).S.copy((yyvsp[-7].PrimType).S);
5770 Value* tmpVal = getVal((yyvsp[-7].PrimType).T, (yyvsp[-6].ValIDVal));
5771 (yyvsp[-3].ValIDVal).S.makeSignless();
5772 BasicBlock* tmpBB = getBBVal((yyvsp[-3].ValIDVal));
5773 SwitchInst *S = new SwitchInst(tmpVal, tmpBB, (yyvsp[-1].JumpTable)->size());
5774 (yyval.TermInstVal).TI = S;
5775 (yyval.TermInstVal).S.makeSignless();
5776 std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = (yyvsp[-1].JumpTable)->begin(),
5777 E = (yyvsp[-1].JumpTable)->end();
5778 for (; I != E; ++I) {
5779 if (ConstantInt *CI = dyn_cast<ConstantInt>(I->first))
5780 S->addCase(CI, I->second);
5782 error("Switch case is constant, but not a simple integer");
5784 delete (yyvsp[-1].JumpTable);
5789 #line 3217 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5791 (yyvsp[-5].ValIDVal).S.copy((yyvsp[-6].PrimType).S);
5792 Value* tmpVal = getVal((yyvsp[-6].PrimType).T, (yyvsp[-5].ValIDVal));
5793 (yyvsp[-2].ValIDVal).S.makeSignless();
5794 BasicBlock* tmpBB = getBBVal((yyvsp[-2].ValIDVal));
5795 SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
5796 (yyval.TermInstVal).TI = S;
5797 (yyval.TermInstVal).S.makeSignless();
5802 #line 3227 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5804 const PointerType *PFTy;
5805 const FunctionType *Ty;
5808 if (!(PFTy = dyn_cast<PointerType>((yyvsp[-10].TypeVal).PAT->get())) ||
5809 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
5810 // Pull out the types of all of the arguments...
5811 std::vector<const Type*> ParamTypes;
5812 FTySign.makeComposite((yyvsp[-10].TypeVal).S);
5813 if ((yyvsp[-7].ValueList)) {
5814 for (std::vector<ValueInfo>::iterator I = (yyvsp[-7].ValueList)->begin(), E = (yyvsp[-7].ValueList)->end();
5816 ParamTypes.push_back((*I).V->getType());
5820 FunctionType::ParamAttrsList ParamAttrs;
5821 if ((yyvsp[-11].UIntVal) == OldCallingConv::CSRet) {
5822 ParamAttrs.push_back(FunctionType::NoAttributeSet);
5823 ParamAttrs.push_back(FunctionType::StructRetAttribute);
5825 bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
5826 if (isVarArg) ParamTypes.pop_back();
5827 Ty = FunctionType::get((yyvsp[-10].TypeVal).PAT->get(), ParamTypes, isVarArg, ParamAttrs);
5828 PFTy = PointerType::get(Ty);
5829 (yyval.TermInstVal).S.copy((yyvsp[-10].TypeVal).S);
5831 FTySign = (yyvsp[-10].TypeVal).S;
5832 (yyval.TermInstVal).S.copy((yyvsp[-10].TypeVal).S.get(0)); // 0th element of FuncTy sign is result ty
5834 (yyvsp[-9].ValIDVal).S.makeComposite(FTySign);
5835 Value *V = getVal(PFTy, (yyvsp[-9].ValIDVal)); // Get the function we're calling...
5836 BasicBlock *Normal = getBBVal((yyvsp[-3].ValIDVal));
5837 BasicBlock *Except = getBBVal((yyvsp[0].ValIDVal));
5839 // Create the call node...
5840 if (!(yyvsp[-7].ValueList)) { // Has no arguments?
5841 (yyval.TermInstVal).TI = new InvokeInst(V, Normal, Except, 0, 0);
5842 } else { // Has arguments?
5843 // Loop through FunctionType's arguments and ensure they are specified
5846 FunctionType::param_iterator I = Ty->param_begin();
5847 FunctionType::param_iterator E = Ty->param_end();
5848 std::vector<ValueInfo>::iterator ArgI = (yyvsp[-7].ValueList)->begin(), ArgE = (yyvsp[-7].ValueList)->end();
5850 std::vector<Value*> Args;
5851 for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
5852 if ((*ArgI).V->getType() != *I)
5853 error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
5854 (*I)->getDescription() + "'");
5855 Args.push_back((*ArgI).V);
5858 if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
5859 error("Invalid number of parameters detected");
5861 (yyval.TermInstVal).TI = new InvokeInst(V, Normal, Except, &Args[0], Args.size());
5863 cast<InvokeInst>((yyval.TermInstVal).TI)->setCallingConv(upgradeCallingConv((yyvsp[-11].UIntVal)));
5864 delete (yyvsp[-10].TypeVal).PAT;
5865 delete (yyvsp[-7].ValueList);
5870 #line 3291 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5872 (yyval.TermInstVal).TI = new UnwindInst();
5873 (yyval.TermInstVal).S.makeSignless();
5878 #line 3295 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5880 (yyval.TermInstVal).TI = new UnreachableInst();
5881 (yyval.TermInstVal).S.makeSignless();
5886 #line 3302 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5888 (yyval.JumpTable) = (yyvsp[-5].JumpTable);
5889 (yyvsp[-3].ValIDVal).S.copy((yyvsp[-4].PrimType).S);
5890 Constant *V = cast<Constant>(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal)));
5893 error("May only switch on a constant pool value");
5895 (yyvsp[0].ValIDVal).S.makeSignless();
5896 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5897 (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
5902 #line 3314 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5904 (yyval.JumpTable) = new std::vector<std::pair<Constant*, BasicBlock*> >();
5905 (yyvsp[-3].ValIDVal).S.copy((yyvsp[-4].PrimType).S);
5906 Constant *V = cast<Constant>(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal)));
5909 error("May only switch on a constant pool value");
5911 (yyvsp[0].ValIDVal).S.makeSignless();
5912 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5913 (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
5918 #line 3329 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5921 if ((yyvsp[-1].StrVal))
5922 if (BitCastInst *BCI = dyn_cast<BitCastInst>((yyvsp[0].InstVal).I))
5923 if (BCI->getSrcTy() == BCI->getDestTy() &&
5924 BCI->getOperand(0)->getName() == (yyvsp[-1].StrVal))
5925 // This is a useless bit cast causing a name redefinition. It is
5926 // a bit cast from a type to the same type of an operand with the
5927 // same name as the name we would give this instruction. Since this
5928 // instruction results in no code generation, it is safe to omit
5929 // the instruction. This situation can occur because of collapsed
5930 // type planes. For example:
5931 // %X = add int %Y, %Z
5932 // %X = cast int %Y to uint
5933 // After upgrade, this looks like:
5934 // %X = add i32 %Y, %Z
5935 // %X = bitcast i32 to i32
5936 // The bitcast is clearly useless so we omit it.
5939 (yyval.InstVal).I = 0;
5940 (yyval.InstVal).S.makeSignless();
5942 ValueInfo VI; VI.V = (yyvsp[0].InstVal).I; VI.S.copy((yyvsp[0].InstVal).S);
5943 setValueName(VI, (yyvsp[-1].StrVal));
5944 InsertValue((yyvsp[0].InstVal).I);
5945 (yyval.InstVal) = (yyvsp[0].InstVal);
5951 #line 3359 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5952 { // Used for PHI nodes
5953 (yyval.PHIList).P = new std::list<std::pair<Value*, BasicBlock*> >();
5954 (yyval.PHIList).S.copy((yyvsp[-5].TypeVal).S);
5955 (yyvsp[-3].ValIDVal).S.copy((yyvsp[-5].TypeVal).S);
5956 Value* tmpVal = getVal((yyvsp[-5].TypeVal).PAT->get(), (yyvsp[-3].ValIDVal));
5957 (yyvsp[-1].ValIDVal).S.makeSignless();
5958 BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
5959 (yyval.PHIList).P->push_back(std::make_pair(tmpVal, tmpBB));
5960 delete (yyvsp[-5].TypeVal).PAT;
5965 #line 3369 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5967 (yyval.PHIList) = (yyvsp[-6].PHIList);
5968 (yyvsp[-3].ValIDVal).S.copy((yyvsp[-6].PHIList).S);
5969 Value* tmpVal = getVal((yyvsp[-6].PHIList).P->front().first->getType(), (yyvsp[-3].ValIDVal));
5970 (yyvsp[-1].ValIDVal).S.makeSignless();
5971 BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
5972 (yyvsp[-6].PHIList).P->push_back(std::make_pair(tmpVal, tmpBB));
5977 #line 3379 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5978 { // Used for call statements, and memory insts...
5979 (yyval.ValueList) = new std::vector<ValueInfo>();
5980 (yyval.ValueList)->push_back((yyvsp[0].ValueVal));
5985 #line 3383 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5987 (yyval.ValueList) = (yyvsp[-2].ValueList);
5988 (yyvsp[-2].ValueList)->push_back((yyvsp[0].ValueVal));
5993 #line 3391 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5994 { (yyval.ValueList) = 0; ;}
5998 #line 3395 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6000 (yyval.BoolVal) = true;
6005 #line 3398 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6007 (yyval.BoolVal) = false;
6012 #line 3404 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6014 (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6015 (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6016 const Type* Ty = (yyvsp[-3].TypeVal).PAT->get();
6017 if (!Ty->isInteger() && !Ty->isFloatingPoint() && !isa<VectorType>(Ty))
6018 error("Arithmetic operator requires integer, FP, or packed operands");
6019 if (isa<VectorType>(Ty) &&
6020 ((yyvsp[-4].BinaryOpVal) == URemOp || (yyvsp[-4].BinaryOpVal) == SRemOp || (yyvsp[-4].BinaryOpVal) == FRemOp || (yyvsp[-4].BinaryOpVal) == RemOp))
6021 error("Remainder not supported on vector types");
6022 // Upgrade the opcode from obsolete versions before we do anything with it.
6023 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S);
6024 Value* val1 = getVal(Ty, (yyvsp[-2].ValIDVal));
6025 Value* val2 = getVal(Ty, (yyvsp[0].ValIDVal));
6026 (yyval.InstVal).I = BinaryOperator::create(Opcode, val1, val2);
6027 if ((yyval.InstVal).I == 0)
6028 error("binary operator returned null");
6029 (yyval.InstVal).S.copy((yyvsp[-3].TypeVal).S);
6030 delete (yyvsp[-3].TypeVal).PAT;
6035 #line 3423 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6037 (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6038 (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6039 const Type *Ty = (yyvsp[-3].TypeVal).PAT->get();
6040 if (!Ty->isInteger()) {
6041 if (!isa<VectorType>(Ty) ||
6042 !cast<VectorType>(Ty)->getElementType()->isInteger())
6043 error("Logical operator requires integral operands");
6045 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S);
6046 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
6047 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
6048 (yyval.InstVal).I = BinaryOperator::create(Opcode, tmpVal1, tmpVal2);
6049 if ((yyval.InstVal).I == 0)
6050 error("binary operator returned null");
6051 (yyval.InstVal).S.copy((yyvsp[-3].TypeVal).S);
6052 delete (yyvsp[-3].TypeVal).PAT;
6057 #line 3441 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6059 (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6060 (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6061 const Type* Ty = (yyvsp[-3].TypeVal).PAT->get();
6062 if(isa<VectorType>(Ty))
6063 error("VectorTypes currently not supported in setcc instructions");
6064 unsigned short pred;
6065 Instruction::OtherOps Opcode = getCompareOp((yyvsp[-4].BinaryOpVal), pred, Ty, (yyvsp[-3].TypeVal).S);
6066 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
6067 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
6068 (yyval.InstVal).I = CmpInst::create(Opcode, pred, tmpVal1, tmpVal2);
6069 if ((yyval.InstVal).I == 0)
6070 error("binary operator returned null");
6071 (yyval.InstVal).S.makeUnsigned();
6072 delete (yyvsp[-3].TypeVal).PAT;
6077 #line 3457 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6079 (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6080 (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6081 const Type *Ty = (yyvsp[-3].TypeVal).PAT->get();
6082 if (isa<VectorType>(Ty))
6083 error("VectorTypes currently not supported in icmp instructions");
6084 else if (!Ty->isInteger() && !isa<PointerType>(Ty))
6085 error("icmp requires integer or pointer typed operands");
6086 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
6087 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
6088 (yyval.InstVal).I = new ICmpInst((yyvsp[-4].IPred), tmpVal1, tmpVal2);
6089 (yyval.InstVal).S.makeUnsigned();
6090 delete (yyvsp[-3].TypeVal).PAT;
6095 #line 3471 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6097 (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6098 (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6099 const Type *Ty = (yyvsp[-3].TypeVal).PAT->get();
6100 if (isa<VectorType>(Ty))
6101 error("VectorTypes currently not supported in fcmp instructions");
6102 else if (!Ty->isFloatingPoint())
6103 error("fcmp instruction requires floating point operands");
6104 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
6105 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
6106 (yyval.InstVal).I = new FCmpInst((yyvsp[-4].FPred), tmpVal1, tmpVal2);
6107 (yyval.InstVal).S.makeUnsigned();
6108 delete (yyvsp[-3].TypeVal).PAT;
6113 #line 3485 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6115 warning("Use of obsolete 'not' instruction: Replacing with 'xor");
6116 const Type *Ty = (yyvsp[0].ValueVal).V->getType();
6117 Value *Ones = ConstantInt::getAllOnesValue(Ty);
6119 error("Expected integral type for not instruction");
6120 (yyval.InstVal).I = BinaryOperator::create(Instruction::Xor, (yyvsp[0].ValueVal).V, Ones);
6121 if ((yyval.InstVal).I == 0)
6122 error("Could not create a xor instruction");
6123 (yyval.InstVal).S.copy((yyvsp[0].ValueVal).S);
6128 #line 3496 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6130 if (!(yyvsp[0].ValueVal).V->getType()->isInteger() ||
6131 cast<IntegerType>((yyvsp[0].ValueVal).V->getType())->getBitWidth() != 8)
6132 error("Shift amount must be int8");
6133 const Type* Ty = (yyvsp[-2].ValueVal).V->getType();
6134 if (!Ty->isInteger())
6135 error("Shift constant expression requires integer operand");
6136 Value* ShiftAmt = 0;
6137 if (cast<IntegerType>(Ty)->getBitWidth() > Type::Int8Ty->getBitWidth())
6138 if (Constant *C = dyn_cast<Constant>((yyvsp[0].ValueVal).V))
6139 ShiftAmt = ConstantExpr::getZExt(C, Ty);
6141 ShiftAmt = new ZExtInst((yyvsp[0].ValueVal).V, Ty, makeNameUnique("shift"), CurBB);
6143 ShiftAmt = (yyvsp[0].ValueVal).V;
6144 (yyval.InstVal).I = BinaryOperator::create(getBinaryOp((yyvsp[-3].BinaryOpVal), Ty, (yyvsp[-2].ValueVal).S), (yyvsp[-2].ValueVal).V, ShiftAmt);
6145 (yyval.InstVal).S.copy((yyvsp[-2].ValueVal).S);
6150 #line 3514 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6152 const Type *DstTy = (yyvsp[0].TypeVal).PAT->get();
6153 if (!DstTy->isFirstClassType())
6154 error("cast instruction to a non-primitive type: '" +
6155 DstTy->getDescription() + "'");
6156 (yyval.InstVal).I = cast<Instruction>(getCast((yyvsp[-3].CastOpVal), (yyvsp[-2].ValueVal).V, (yyvsp[-2].ValueVal).S, DstTy, (yyvsp[0].TypeVal).S, true));
6157 (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S);
6158 delete (yyvsp[0].TypeVal).PAT;
6163 #line 3523 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6165 if (!(yyvsp[-4].ValueVal).V->getType()->isInteger() ||
6166 cast<IntegerType>((yyvsp[-4].ValueVal).V->getType())->getBitWidth() != 1)
6167 error("select condition must be bool");
6168 if ((yyvsp[-2].ValueVal).V->getType() != (yyvsp[0].ValueVal).V->getType())
6169 error("select value types should match");
6170 (yyval.InstVal).I = new SelectInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
6171 (yyval.InstVal).S.copy((yyvsp[-2].ValueVal).S);
6176 #line 3532 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6178 const Type *Ty = (yyvsp[0].TypeVal).PAT->get();
6180 (yyval.InstVal).I = new VAArgInst((yyvsp[-2].ValueVal).V, Ty);
6181 (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S);
6182 delete (yyvsp[0].TypeVal).PAT;
6187 #line 3539 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6189 const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType();
6190 const Type* DstTy = (yyvsp[0].TypeVal).PAT->get();
6191 ObsoleteVarArgs = true;
6192 Function* NF = cast<Function>(CurModule.CurrentModule->
6193 getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
6196 //foo = alloca 1 of t
6200 AllocaInst* foo = new AllocaInst(ArgTy, 0, "vaarg.fix");
6201 CurBB->getInstList().push_back(foo);
6202 CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V);
6203 CurBB->getInstList().push_back(bar);
6204 CurBB->getInstList().push_back(new StoreInst(bar, foo));
6205 (yyval.InstVal).I = new VAArgInst(foo, DstTy);
6206 (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S);
6207 delete (yyvsp[0].TypeVal).PAT;
6212 #line 3560 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6214 const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType();
6215 const Type* DstTy = (yyvsp[0].TypeVal).PAT->get();
6216 ObsoleteVarArgs = true;
6217 Function* NF = cast<Function>(CurModule.CurrentModule->
6218 getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
6220 //b = vanext a, t ->
6221 //foo = alloca 1 of t
6224 //tmp = vaarg foo, t
6226 AllocaInst* foo = new AllocaInst(ArgTy, 0, "vanext.fix");
6227 CurBB->getInstList().push_back(foo);
6228 CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V);
6229 CurBB->getInstList().push_back(bar);
6230 CurBB->getInstList().push_back(new StoreInst(bar, foo));
6231 Instruction* tmp = new VAArgInst(foo, DstTy);
6232 CurBB->getInstList().push_back(tmp);
6233 (yyval.InstVal).I = new LoadInst(foo);
6234 (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S);
6235 delete (yyvsp[0].TypeVal).PAT;
6240 #line 3584 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6242 if (!ExtractElementInst::isValidOperands((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
6243 error("Invalid extractelement operands");
6244 (yyval.InstVal).I = new ExtractElementInst((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
6245 (yyval.InstVal).S.copy((yyvsp[-2].ValueVal).S.get(0));
6250 #line 3590 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6252 if (!InsertElementInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
6253 error("Invalid insertelement operands");
6254 (yyval.InstVal).I = new InsertElementInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
6255 (yyval.InstVal).S.copy((yyvsp[-4].ValueVal).S);
6260 #line 3596 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6262 if (!ShuffleVectorInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
6263 error("Invalid shufflevector operands");
6264 (yyval.InstVal).I = new ShuffleVectorInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
6265 (yyval.InstVal).S.copy((yyvsp[-4].ValueVal).S);
6270 #line 3602 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6272 const Type *Ty = (yyvsp[0].PHIList).P->front().first->getType();
6273 if (!Ty->isFirstClassType())
6274 error("PHI node operands must be of first class type");
6275 PHINode *PHI = new PHINode(Ty);
6276 PHI->reserveOperandSpace((yyvsp[0].PHIList).P->size());
6277 while ((yyvsp[0].PHIList).P->begin() != (yyvsp[0].PHIList).P->end()) {
6278 if ((yyvsp[0].PHIList).P->front().first->getType() != Ty)
6279 error("All elements of a PHI node must be of the same type");
6280 PHI->addIncoming((yyvsp[0].PHIList).P->front().first, (yyvsp[0].PHIList).P->front().second);
6281 (yyvsp[0].PHIList).P->pop_front();
6283 (yyval.InstVal).I = PHI;
6284 (yyval.InstVal).S.copy((yyvsp[0].PHIList).S);
6285 delete (yyvsp[0].PHIList).P; // Free the list...
6290 #line 3618 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6292 // Handle the short call syntax
6293 const PointerType *PFTy;
6294 const FunctionType *FTy;
6296 if (!(PFTy = dyn_cast<PointerType>((yyvsp[-4].TypeVal).PAT->get())) ||
6297 !(FTy = dyn_cast<FunctionType>(PFTy->getElementType()))) {
6298 // Pull out the types of all of the arguments...
6299 std::vector<const Type*> ParamTypes;
6300 FTySign.makeComposite((yyvsp[-4].TypeVal).S);
6301 if ((yyvsp[-1].ValueList)) {
6302 for (std::vector<ValueInfo>::iterator I = (yyvsp[-1].ValueList)->begin(), E = (yyvsp[-1].ValueList)->end();
6304 ParamTypes.push_back((*I).V->getType());
6309 FunctionType::ParamAttrsList ParamAttrs;
6310 if ((yyvsp[-5].UIntVal) == OldCallingConv::CSRet) {
6311 ParamAttrs.push_back(FunctionType::NoAttributeSet);
6312 ParamAttrs.push_back(FunctionType::StructRetAttribute);
6314 bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
6315 if (isVarArg) ParamTypes.pop_back();
6317 const Type *RetTy = (yyvsp[-4].TypeVal).PAT->get();
6318 if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
6319 error("Functions cannot return aggregate types");
6321 FTy = FunctionType::get(RetTy, ParamTypes, isVarArg, ParamAttrs);
6322 PFTy = PointerType::get(FTy);
6323 (yyval.InstVal).S.copy((yyvsp[-4].TypeVal).S);
6325 FTySign = (yyvsp[-4].TypeVal).S;
6326 (yyval.InstVal).S.copy((yyvsp[-4].TypeVal).S.get(0)); // 0th element of FuncTy signedness is result sign
6328 (yyvsp[-3].ValIDVal).S.makeComposite(FTySign);
6330 // First upgrade any intrinsic calls.
6331 std::vector<Value*> Args;
6332 if ((yyvsp[-1].ValueList))
6333 for (unsigned i = 0, e = (yyvsp[-1].ValueList)->size(); i < e; ++i)
6334 Args.push_back((*(yyvsp[-1].ValueList))[i].V);
6335 Instruction *Inst = upgradeIntrinsicCall(FTy, (yyvsp[-3].ValIDVal), Args);
6337 // If we got an upgraded intrinsic
6339 (yyval.InstVal).I = Inst;
6341 // Get the function we're calling
6342 Value *V = getVal(PFTy, (yyvsp[-3].ValIDVal));
6344 // Check the argument values match
6345 if (!(yyvsp[-1].ValueList)) { // Has no arguments?
6346 // Make sure no arguments is a good thing!
6347 if (FTy->getNumParams() != 0)
6348 error("No arguments passed to a function that expects arguments");
6349 } else { // Has arguments?
6350 // Loop through FunctionType's arguments and ensure they are specified
6353 FunctionType::param_iterator I = FTy->param_begin();
6354 FunctionType::param_iterator E = FTy->param_end();
6355 std::vector<ValueInfo>::iterator ArgI = (yyvsp[-1].ValueList)->begin(), ArgE = (yyvsp[-1].ValueList)->end();
6357 for (; ArgI != ArgE && I != E; ++ArgI, ++I)
6358 if ((*ArgI).V->getType() != *I)
6359 error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
6360 (*I)->getDescription() + "'");
6362 if (I != E || (ArgI != ArgE && !FTy->isVarArg()))
6363 error("Invalid number of parameters detected");
6366 // Create the call instruction
6367 CallInst *CI = new CallInst(V, &Args[0], Args.size());
6368 CI->setTailCall((yyvsp[-6].BoolVal));
6369 CI->setCallingConv(upgradeCallingConv((yyvsp[-5].UIntVal)));
6370 (yyval.InstVal).I = CI;
6372 delete (yyvsp[-4].TypeVal).PAT;
6373 delete (yyvsp[-1].ValueList);
6378 #line 3702 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6380 (yyval.InstVal) = (yyvsp[0].InstVal);
6385 #line 3710 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6386 { (yyval.ValueList) = (yyvsp[0].ValueList); ;}
6390 #line 3711 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6391 { (yyval.ValueList) = new std::vector<ValueInfo>(); ;}
6395 #line 3715 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6396 { (yyval.BoolVal) = true; ;}
6400 #line 3716 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6401 { (yyval.BoolVal) = false; ;}
6405 #line 3720 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6407 const Type *Ty = (yyvsp[-1].TypeVal).PAT->get();
6408 (yyval.InstVal).S.makeComposite((yyvsp[-1].TypeVal).S);
6409 (yyval.InstVal).I = new MallocInst(Ty, 0, (yyvsp[0].UIntVal));
6410 delete (yyvsp[-1].TypeVal).PAT;
6415 #line 3726 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6417 const Type *Ty = (yyvsp[-4].TypeVal).PAT->get();
6418 (yyvsp[-1].ValIDVal).S.makeUnsigned();
6419 (yyval.InstVal).S.makeComposite((yyvsp[-4].TypeVal).S);
6420 (yyval.InstVal).I = new MallocInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal));
6421 delete (yyvsp[-4].TypeVal).PAT;
6426 #line 3733 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6428 const Type *Ty = (yyvsp[-1].TypeVal).PAT->get();
6429 (yyval.InstVal).S.makeComposite((yyvsp[-1].TypeVal).S);
6430 (yyval.InstVal).I = new AllocaInst(Ty, 0, (yyvsp[0].UIntVal));
6431 delete (yyvsp[-1].TypeVal).PAT;
6436 #line 3739 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6438 const Type *Ty = (yyvsp[-4].TypeVal).PAT->get();
6439 (yyvsp[-1].ValIDVal).S.makeUnsigned();
6440 (yyval.InstVal).S.makeComposite((yyvsp[-2].PrimType).S);
6441 (yyval.InstVal).I = new AllocaInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal));
6442 delete (yyvsp[-4].TypeVal).PAT;
6447 #line 3746 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6449 const Type *PTy = (yyvsp[0].ValueVal).V->getType();
6450 if (!isa<PointerType>(PTy))
6451 error("Trying to free nonpointer type '" + PTy->getDescription() + "'");
6452 (yyval.InstVal).I = new FreeInst((yyvsp[0].ValueVal).V);
6453 (yyval.InstVal).S.makeSignless();
6458 #line 3753 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6460 const Type* Ty = (yyvsp[-1].TypeVal).PAT->get();
6461 (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S);
6462 if (!isa<PointerType>(Ty))
6463 error("Can't load from nonpointer type: " + Ty->getDescription());
6464 if (!cast<PointerType>(Ty)->getElementType()->isFirstClassType())
6465 error("Can't load from pointer of non-first-class type: " +
6466 Ty->getDescription());
6467 Value* tmpVal = getVal(Ty, (yyvsp[0].ValIDVal));
6468 (yyval.InstVal).I = new LoadInst(tmpVal, "", (yyvsp[-3].BoolVal));
6469 (yyval.InstVal).S.copy((yyvsp[-1].TypeVal).S.get(0));
6470 delete (yyvsp[-1].TypeVal).PAT;
6475 #line 3766 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6477 (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S);
6478 const PointerType *PTy = dyn_cast<PointerType>((yyvsp[-1].TypeVal).PAT->get());
6480 error("Can't store to a nonpointer type: " +
6481 (yyvsp[-1].TypeVal).PAT->get()->getDescription());
6482 const Type *ElTy = PTy->getElementType();
6483 Value *StoreVal = (yyvsp[-3].ValueVal).V;
6484 Value* tmpVal = getVal(PTy, (yyvsp[0].ValIDVal));
6485 if (ElTy != (yyvsp[-3].ValueVal).V->getType()) {
6486 StoreVal = handleSRetFuncTypeMerge((yyvsp[-3].ValueVal).V, ElTy);
6488 error("Can't store '" + (yyvsp[-3].ValueVal).V->getType()->getDescription() +
6489 "' into space of type '" + ElTy->getDescription() + "'");
6491 PTy = PointerType::get(StoreVal->getType());
6492 if (Constant *C = dyn_cast<Constant>(tmpVal))
6493 tmpVal = ConstantExpr::getBitCast(C, PTy);
6495 tmpVal = new BitCastInst(tmpVal, PTy, "upgrd.cast", CurBB);
6498 (yyval.InstVal).I = new StoreInst(StoreVal, tmpVal, (yyvsp[-5].BoolVal));
6499 (yyval.InstVal).S.makeSignless();
6500 delete (yyvsp[-1].TypeVal).PAT;
6505 #line 3792 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6507 (yyvsp[-1].ValIDVal).S.copy((yyvsp[-2].TypeVal).S);
6508 const Type* Ty = (yyvsp[-2].TypeVal).PAT->get();
6509 if (!isa<PointerType>(Ty))
6510 error("getelementptr insn requires pointer operand");
6512 std::vector<Value*> VIndices;
6513 upgradeGEPIndices(Ty, (yyvsp[0].ValueList), VIndices);
6515 Value* tmpVal = getVal(Ty, (yyvsp[-1].ValIDVal));
6516 (yyval.InstVal).I = new GetElementPtrInst(tmpVal, &VIndices[0], VIndices.size());
6517 ValueInfo VI; VI.V = tmpVal; VI.S.copy((yyvsp[-2].TypeVal).S);
6518 (yyval.InstVal).S.copy(getElementSign(VI, VIndices));
6519 delete (yyvsp[-2].TypeVal).PAT;
6520 delete (yyvsp[0].ValueList);
6528 /* Line 1126 of yacc.c. */
6529 #line 6528 "UpgradeParser.tab.c"
6535 YY_STACK_PRINT (yyss, yyssp);
6540 /* Now `shift' the result of the reduction. Determine what state
6541 that goes to, based on the state we popped back to and the rule
6542 number reduced by. */
6546 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
6547 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
6548 yystate = yytable[yystate];
6550 yystate = yydefgoto[yyn - YYNTOKENS];
6555 /*------------------------------------.
6556 | yyerrlab -- here on detecting error |
6557 `------------------------------------*/
6559 /* If not already recovering from an error, report this error. */
6564 yyn = yypact[yystate];
6566 if (YYPACT_NINF < yyn && yyn < YYLAST)
6568 int yytype = YYTRANSLATE (yychar);
6569 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
6570 YYSIZE_T yysize = yysize0;
6572 int yysize_overflow = 0;
6574 # define YYERROR_VERBOSE_ARGS_MAXIMUM 5
6575 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
6579 /* This is so xgettext sees the translatable formats that are
6580 constructed on the fly. */
6581 YY_("syntax error, unexpected %s");
6582 YY_("syntax error, unexpected %s, expecting %s");
6583 YY_("syntax error, unexpected %s, expecting %s or %s");
6584 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
6585 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
6589 static char const yyunexpected[] = "syntax error, unexpected %s";
6590 static char const yyexpecting[] = ", expecting %s";
6591 static char const yyor[] = " or %s";
6592 char yyformat[sizeof yyunexpected
6593 + sizeof yyexpecting - 1
6594 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
6595 * (sizeof yyor - 1))];
6596 char const *yyprefix = yyexpecting;
6598 /* Start YYX at -YYN if negative to avoid negative indexes in
6600 int yyxbegin = yyn < 0 ? -yyn : 0;
6602 /* Stay within bounds of both yycheck and yytname. */
6603 int yychecklim = YYLAST - yyn;
6604 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
6607 yyarg[0] = yytname[yytype];
6608 yyfmt = yystpcpy (yyformat, yyunexpected);
6610 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
6611 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
6613 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
6617 yyformat[sizeof yyunexpected - 1] = '\0';
6620 yyarg[yycount++] = yytname[yyx];
6621 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
6622 yysize_overflow |= yysize1 < yysize;
6624 yyfmt = yystpcpy (yyfmt, yyprefix);
6628 yyf = YY_(yyformat);
6629 yysize1 = yysize + yystrlen (yyf);
6630 yysize_overflow |= yysize1 < yysize;
6633 if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
6634 yymsg = (char *) YYSTACK_ALLOC (yysize);
6637 /* Avoid sprintf, as that infringes on the user's name space.
6638 Don't have undefined behavior even if the translation
6639 produced a string with the wrong number of "%s"s. */
6642 while ((*yyp = *yyf))
6644 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
6646 yyp += yytnamerr (yyp, yyarg[yyi++]);
6656 YYSTACK_FREE (yymsg);
6660 yyerror (YY_("syntax error"));
6661 goto yyexhaustedlab;
6665 #endif /* YYERROR_VERBOSE */
6666 yyerror (YY_("syntax error"));
6671 if (yyerrstatus == 3)
6673 /* If just tried and failed to reuse look-ahead token after an
6674 error, discard it. */
6676 if (yychar <= YYEOF)
6678 /* Return failure if at end of input. */
6679 if (yychar == YYEOF)
6684 yydestruct ("Error: discarding", yytoken, &yylval);
6689 /* Else will try to reuse look-ahead token after shifting the error
6694 /*---------------------------------------------------.
6695 | yyerrorlab -- error raised explicitly by YYERROR. |
6696 `---------------------------------------------------*/
6699 /* Pacify compilers like GCC when the user code never invokes
6700 YYERROR and the label yyerrorlab therefore never appears in user
6711 /*-------------------------------------------------------------.
6712 | yyerrlab1 -- common code for both syntax error and YYERROR. |
6713 `-------------------------------------------------------------*/
6715 yyerrstatus = 3; /* Each real token shifted decrements this. */
6719 yyn = yypact[yystate];
6720 if (yyn != YYPACT_NINF)
6723 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
6731 /* Pop the current state because it cannot handle the error token. */
6736 yydestruct ("Error: popping", yystos[yystate], yyvsp);
6739 YY_STACK_PRINT (yyss, yyssp);
6748 /* Shift the error token. */
6749 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
6755 /*-------------------------------------.
6756 | yyacceptlab -- YYACCEPT comes here. |
6757 `-------------------------------------*/
6762 /*-----------------------------------.
6763 | yyabortlab -- YYABORT comes here. |
6764 `-----------------------------------*/
6770 /*-------------------------------------------------.
6771 | yyexhaustedlab -- memory exhaustion comes here. |
6772 `-------------------------------------------------*/
6774 yyerror (YY_("memory exhausted"));
6780 if (yychar != YYEOF && yychar != YYEMPTY)
6781 yydestruct ("Cleanup: discarding lookahead",
6783 while (yyssp != yyss)
6785 yydestruct ("Cleanup: popping",
6786 yystos[*yyssp], yyvsp);
6791 YYSTACK_FREE (yyss);
6797 #line 3810 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6800 int yyerror(const char *ErrorMsg) {
6802 = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
6803 + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
6804 std::string errMsg = where + "error: " + std::string(ErrorMsg);
6805 if (yychar != YYEMPTY && yychar != 0)
6806 errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
6808 std::cerr << "llvm-upgrade: " << errMsg << '\n';
6809 std::cout << "llvm-upgrade: parse failed.\n";
6813 void warning(const std::string& ErrorMsg) {
6815 = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
6816 + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
6817 std::string errMsg = where + "warning: " + std::string(ErrorMsg);
6818 if (yychar != YYEMPTY && yychar != 0)
6819 errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
6821 std::cerr << "llvm-upgrade: " << errMsg << '\n';
6824 void error(const std::string& ErrorMsg, int LineNo) {
6825 if (LineNo == -1) LineNo = Upgradelineno;
6826 Upgradelineno = LineNo;
6827 yyerror(ErrorMsg.c_str());