llvm.org GIT mirror llvm / 930c0fe
Fix MemoryBuffer breakage correctly. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36561 91177308-0d34-0410-b5e6-96231b3b80d8 Jeff Cohen 13 years ago
4 changed file(s) with 1673 addition(s) and 1888 deletion(s). Raw diff Collapse all Expand all
558558 explicit PathWithStatus(const std::string& p)
559559 : Path(p), status(), fsIsValid(false) {}
560560
561 /// This constructor will accept a character range as a path. No checking
562 /// is done on this path to determine if it is valid. To determine
563 /// validity of the path, use the isValid method.
564 /// @param p The path to assign.
565 /// @brief Construct a Path from a string.
566 explicit PathWithStatus(const char *StrStart, unsigned StrLen)
567 : Path(StrStart, StrLen), status(), fsIsValid(false) {}
568
561569 /// Makes a copy of \p that to \p this.
562570 /// @returns \p this
563571 /// @brief Assignment Operator
None /* A Bison parser, made by GNU Bison 2.1. */
0 /* A Bison parser, made from /usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y, by GNU bison 1.75. */
11
22 /* Skeleton parser for Yacc-like parsing with Bison,
3 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
3 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
44
55 This program is free software; you can redistribute it and/or modify
66 it under the terms of the GNU General Public License as published by
1414
1515 You should have received a copy of the GNU General Public License
1616 along with this program; if not, write to the Free Software
17 Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 Boston, MA 02110-1301, USA. */
17 Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
1919
2020 /* As a special exception, when this file is copied by Bison into a
2121 Bison output file, you may use that output file without restriction.
3333 USER NAME SPACE" below. */
3434
3535 /* Identify Bison output. */
36 #define YYBISON 1
37
38 /* Bison version. */
39 #define YYBISON_VERSION "2.1"
40
41 /* Skeleton name. */
42 #define YYSKELETON_NAME "yacc.c"
36 #define YYBISON 1
4337
4438 /* Pure parsers. */
45 #define YYPURE 0
39 #define YYPURE 0
4640
4741 /* Using locations. */
4842 #define YYLSP_NEEDED 0
4943
50 /* Substitute the variable and function names. */
44 /* If NAME_PREFIX is specified substitute the variables and functions
45 names. */
5146 #define yyparse llvmAsmparse
5247 #define yylex llvmAsmlex
5348 #define yyerror llvmAsmerror
198193 HIDDEN = 390
199194 };
200195 #endif
201 /* Tokens. */
202196 #define ESINT64VAL 258
203197 #define EUINT64VAL 259
204198 #define ESAPINTVAL 260
337331
338332
339333 /* Copy the first part of user declarations. */
340 #line 14 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
334 #line 14 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
341335
342336 #include "ParserInternals.h"
343337 #include "llvm/CallingConv.h"
12921286 # define YYERROR_VERBOSE 0
12931287 #endif
12941288
1295 /* Enabling the token table. */
1296 #ifndef YYTOKEN_TABLE
1297 # define YYTOKEN_TABLE 0
1298 #endif
1299
1300 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
1301 #line 955 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
1302 typedef union YYSTYPE {
1289 #ifndef YYSTYPE
1290 #line 955 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
1291 typedef union {
13031292 llvm::Module *ModuleVal;
13041293 llvm::Function *FunctionVal;
13051294 llvm::BasicBlock *BasicBlockVal;
13441333 llvm::Instruction::OtherOps OtherOpVal;
13451334 llvm::ICmpInst::Predicate IPredicate;
13461335 llvm::FCmpInst::Predicate FPredicate;
1347 } YYSTYPE;
1348 /* Line 196 of yacc.c. */
1349 #line 1351 "llvmAsmParser.tab.c"
1350 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1351 # define YYSTYPE_IS_DECLARED 1
1336 } yystype;
1337 /* Line 188 of /usr/local/share/bison/yacc.c. */
1338 #line 1340 "llvmAsmParser.tab.c"
1339 # define YYSTYPE yystype
13521340 # define YYSTYPE_IS_TRIVIAL 1
13531341 #endif
13541342
1355
1343 #ifndef YYLTYPE
1344 typedef struct yyltype
1345 {
1346 int first_line;
1347 int first_column;
1348 int last_line;
1349 int last_column;
1350 } yyltype;
1351 # define YYLTYPE yyltype
1352 # define YYLTYPE_IS_TRIVIAL 1
1353 #endif
13561354
13571355 /* Copy the second part of user declarations. */
13581356
13591357
1360 /* Line 219 of yacc.c. */
1361 #line 1363 "llvmAsmParser.tab.c"
1362
1363 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
1364 # define YYSIZE_T __SIZE_TYPE__
1365 #endif
1366 #if ! defined (YYSIZE_T) && defined (size_t)
1367 # define YYSIZE_T size_t
1368 #endif
1369 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
1370 # include /* INFRINGES ON USER NAME SPACE */
1371 # define YYSIZE_T size_t
1372 #endif
1373 #if ! defined (YYSIZE_T)
1374 # define YYSIZE_T unsigned int
1375 #endif
1376
1377 #ifndef YY_
1378 # if YYENABLE_NLS
1379 # if ENABLE_NLS
1380 # include /* INFRINGES ON USER NAME SPACE */
1381 # define YY_(msgid) dgettext ("bison-runtime", msgid)
1382 # endif
1383 # endif
1384 # ifndef YY_
1385 # define YY_(msgid) msgid
1386 # endif
1387 #endif
1358 /* Line 213 of /usr/local/share/bison/yacc.c. */
1359 #line 1361 "llvmAsmParser.tab.c"
13881360
13891361 #if ! defined (yyoverflow) || YYERROR_VERBOSE
13901362
13911363 /* The parser invokes alloca or malloc; define the necessary symbols. */
13921364
1393 # ifdef YYSTACK_USE_ALLOCA
1394 # if YYSTACK_USE_ALLOCA
1395 # ifdef __GNUC__
1396 # define YYSTACK_ALLOC __builtin_alloca
1365 # if YYSTACK_USE_ALLOCA
1366 # define YYSTACK_ALLOC alloca
1367 # else
1368 # ifndef YYSTACK_USE_ALLOCA
1369 # if defined (alloca) || defined (_ALLOCA_H)
1370 # define YYSTACK_ALLOC alloca
13971371 # else
1398 # define YYSTACK_ALLOC alloca
1399 # if defined (__STDC__) || defined (__cplusplus)
1400 # include /* INFRINGES ON USER NAME SPACE */
1401 # define YYINCLUDED_STDLIB_H
1372 # ifdef __GNUC__
1373 # define YYSTACK_ALLOC __builtin_alloca
14021374 # endif
14031375 # endif
14041376 # endif
14071379 # ifdef YYSTACK_ALLOC
14081380 /* Pacify GCC's `empty if-body' warning. */
14091381 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
1410 # ifndef YYSTACK_ALLOC_MAXIMUM
1411 /* The OS might guarantee only one guard page at the bottom of the stack,
1412 and a page size can be as small as 4096 bytes. So we cannot safely
1413 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1414 to allow for a few compiler-allocated temporary stack slots. */
1415 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
1382 # else
1383 # if defined (__STDC__) || defined (__cplusplus)
1384 # include /* INFRINGES ON USER NAME SPACE */
1385 # define YYSIZE_T size_t
14161386 # endif
1417 # else
1418 # define YYSTACK_ALLOC YYMALLOC
1419 # define YYSTACK_FREE YYFREE
1420 # ifndef YYSTACK_ALLOC_MAXIMUM
1421 # define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
1422 # endif
1423 # ifdef __cplusplus
1424 extern "C" {
1425 # endif
1426 # ifndef YYMALLOC
1427 # define YYMALLOC malloc
1428 # if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
1429 && (defined (__STDC__) || defined (__cplusplus)))
1430 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1431 # endif
1432 # endif
1433 # ifndef YYFREE
1434 # define YYFREE free
1435 # if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
1436 && (defined (__STDC__) || defined (__cplusplus)))
1437 void free (void *); /* INFRINGES ON USER NAME SPACE */
1438 # endif
1439 # endif
1440 # ifdef __cplusplus
1441 }
1442 # endif
1387 # define YYSTACK_ALLOC malloc
1388 # define YYSTACK_FREE free
14431389 # endif
14441390 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
14451391
14461392
14471393 #if (! defined (yyoverflow) \
14481394 && (! defined (__cplusplus) \
1449 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
1395 || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
14501396
14511397 /* A type that is properly aligned for any stack member. */
14521398 union yyalloc
14531399 {
1454 short int yyss;
1400 short yyss;
14551401 YYSTYPE yyvs;
14561402 };
14571403
14581404 /* The size of the maximum gap between one aligned stack and the next. */
1459 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1405 # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
14601406
14611407 /* The size of an array large to enough to hold all stacks, each with
14621408 N elements. */
14631409 # define YYSTACK_BYTES(N) \
1464 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
1465 + YYSTACK_GAP_MAXIMUM)
1410 ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
1411 + YYSTACK_GAP_MAX)
14661412
14671413 /* Copy COUNT objects from FROM to TO. The source and destination do
14681414 not overlap. */
14691415 # ifndef YYCOPY
1470 # if defined (__GNUC__) && 1 < __GNUC__
1416 # if 1 < __GNUC__
14711417 # define YYCOPY(To, From, Count) \
14721418 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
14731419 # else
14741420 # define YYCOPY(To, From, Count) \
14751421 do \
14761422 { \
1477 YYSIZE_T yyi; \
1423 register YYSIZE_T yyi; \
14781424 for (yyi = 0; yyi < (Count); yyi++) \
1479 (To)[yyi] = (From)[yyi]; \
1425 (To)[yyi] = (From)[yyi]; \
14801426 } \
14811427 while (0)
14821428 # endif
14931439 YYSIZE_T yynewbytes; \
14941440 YYCOPY (&yyptr->Stack, Stack, yysize); \
14951441 Stack = &yyptr->Stack; \
1496 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1442 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \
14971443 yyptr += yynewbytes / sizeof (*yyptr); \
14981444 } \
14991445 while (0)
15031449 #if defined (__STDC__) || defined (__cplusplus)
15041450 typedef signed char yysigned_char;
15051451 #else
1506 typedef short int yysigned_char;
1452 typedef short yysigned_char;
15071453 #endif
15081454
15091455 /* YYFINAL -- State number of the termination state. */
15101456 #define YYFINAL 41
1511 /* YYLAST -- Last index in YYTABLE. */
15121457 #define YYLAST 1600
15131458
15141459 /* YYNTOKENS -- Number of terminals. */
15241469 #define YYUNDEFTOK 2
15251470 #define YYMAXUTOK 390
15261471
1527 #define YYTRANSLATE(YYX) \
1528 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1472 #define YYTRANSLATE(X) \
1473 ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK)
15291474
15301475 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
15311476 static const unsigned char yytranslate[] =
15751520 #if YYDEBUG
15761521 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
15771522 YYRHS. */
1578 static const unsigned short int yyprhs[] =
1523 static const unsigned short yyprhs[] =
15791524 {
15801525 0, 0, 3, 5, 7, 9, 11, 13, 15, 17,
15811526 19, 21, 23, 25, 27, 29, 31, 33, 35, 37,
16101555 };
16111556
16121557 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1613 static const short int yyrhs[] =
1558 static const short yyrhs[] =
16141559 {
16151560 194, 0, -1, 69, -1, 70, -1, 71, -1, 72,
16161561 -1, 73, -1, 74, -1, 75, -1, 76, -1, 77,
17091654 };
17101655
17111656 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1712 static const unsigned short int yyrline[] =
1657 static const unsigned short yyrline[] =
17131658 {
17141659 0, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111,
17151660 1111, 1112, 1112, 1112, 1112, 1112, 1112, 1113, 1113, 1113,
1716 1113, 1113, 1113, 1114, 1114, 1114, 1114, 1114, 1114, 1117,
1661 1113, 1113, 1113, 1113, 1114, 1114, 1114, 1114, 1114, 1117,
17171662 1117, 1118, 1118, 1119, 1119, 1120, 1120, 1121, 1121, 1125,
17181663 1125, 1126, 1126, 1127, 1127, 1128, 1128, 1129, 1129, 1130,
17191664 1130, 1131, 1131, 1132, 1133, 1138, 1139, 1139, 1141, 1141,
17201665 1142, 1142, 1146, 1150, 1155, 1155, 1157, 1158, 1163, 1169,
17211666 1170, 1171, 1172, 1173, 1177, 1178, 1179, 1183, 1184, 1185,
17221667 1189, 1190, 1191, 1195, 1196, 1197, 1198, 1199, 1203, 1204,
1723 1205, 1208, 1209, 1210, 1211, 1212, 1213, 1214, 1221, 1222,
1668 1205, 1208, 1208, 1209, 1210, 1211, 1212, 1213, 1221, 1222,
17241669 1223, 1224, 1227, 1228, 1233, 1234, 1235, 1238, 1239, 1246,
1725 1247, 1253, 1254, 1262, 1270, 1271, 1276, 1277, 1278, 1283,
1670 1246, 1253, 1253, 1262, 1270, 1270, 1276, 1276, 1278, 1283,
17261671 1296, 1296, 1296, 1296, 1299, 1303, 1307, 1314, 1319, 1327,
17271672 1357, 1388, 1393, 1405, 1415, 1419, 1429, 1436, 1443, 1450,
17281673 1455, 1460, 1467, 1468, 1475, 1482, 1490, 1496, 1508, 1536,
17441689 };
17451690 #endif
17461691
1747 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1748 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1692 #if YYDEBUG || YYERROR_VERBOSE
1693 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
17491694 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
17501695 static const char *const yytname[] =
17511696 {
1752 "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "ESAPINTVAL",
1753 "EUAPINTVAL", "LOCALVAL_ID", "GLOBALVAL_ID", "FPVAL", "VOID", "INTTYPE",
1754 "FLOAT", "DOUBLE", "LABEL", "TYPE", "LOCALVAR", "GLOBALVAR", "LABELSTR",
1755 "STRINGCONSTANT", "ATSTRINGCONSTANT", "ZEROINITIALIZER", "TRUETOK",
1756 "FALSETOK", "BEGINTOK", "ENDTOK", "DECLARE", "DEFINE", "GLOBAL",
1757 "CONSTANT", "SECTION", "ALIAS", "VOLATILE", "THREAD_LOCAL", "TO",
1758 "DOTDOTDOT", "NULL_TOK", "UNDEF", "INTERNAL", "LINKONCE", "WEAK",
1759 "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "OPAQUE",
1760 "EXTERNAL", "TARGET", "TRIPLE", "ALIGN", "DEPLIBS", "CALL", "TAIL",
1761 "ASM_TOK", "MODULE", "SIDEEFFECT", "CC_TOK", "CCC_TOK", "FASTCC_TOK",
1762 "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT",
1763 "RET", "BR", "SWITCH", "INVOKE", "UNWIND", "UNREACHABLE", "ADD", "SUB",
1764 "MUL", "UDIV", "SDIV", "FDIV", "UREM", "SREM", "FREM", "AND", "OR",
1765 "XOR", "SHL", "LSHR", "ASHR", "ICMP", "FCMP", "EQ", "NE", "SLT", "SGT",
1766 "SLE", "SGE", "ULT", "UGT", "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT",
1767 "OLE", "OGE", "ORD", "UNO", "UEQ", "UNE", "MALLOC", "ALLOCA", "FREE",
1768 "LOAD", "STORE", "GETELEMENTPTR", "TRUNC", "ZEXT", "SEXT", "FPTRUNC",
1769 "FPEXT", "BITCAST", "UITOFP", "SITOFP", "FPTOUI", "FPTOSI", "INTTOPTR",
1770 "PTRTOINT", "PHI_TOK", "SELECT", "VAARG", "EXTRACTELEMENT",
1771 "INSERTELEMENT", "SHUFFLEVECTOR", "NORETURN", "INREG", "SRET",
1772 "NOUNWIND", "DEFAULT", "HIDDEN", "'='", "','", "'*'", "'\\\\'", "'('",
1773 "')'", "'['", "'x'", "']'", "'<'", "'>'", "'{'", "'}'", "'c'", "$accept",
1774 "ArithmeticOps", "LogicalOps", "CastOps", "IPredicates", "FPredicates",
1775 "IntType", "FPType", "LocalName", "OptLocalName", "OptLocalAssign",
1776 "GlobalName", "OptGlobalAssign", "GlobalAssign", "GVInternalLinkage",
1777 "GVExternalLinkage", "GVVisibilityStyle", "FunctionDeclareLinkage",
1778 "FunctionDefineLinkage", "AliasLinkage", "OptCallingConv", "ParamAttr",
1779 "OptParamAttrs", "FuncAttr", "OptFuncAttrs", "OptAlign", "OptCAlign",
1780 "SectionString", "OptSection", "GlobalVarAttributes",
1781 "GlobalVarAttribute", "PrimType", "Types", "ArgType", "ResultTypes",
1782 "ArgTypeList", "ArgTypeListI", "TypeListI", "ConstVal", "ConstExpr",
1783 "ConstVector", "GlobalType", "ThreadLocal", "AliaseeRef", "Module",
1784 "DefinitionList", "Definition", "@1", "@2", "@3", "@4", "@5", "AsmBlock",
1785 "TargetDefinition", "LibrariesDefinition", "LibList", "ArgListH",
1786 "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader", "END",
1787 "Function", "FunctionProto", "OptSideEffect", "ConstValueRef",
1788 "SymbolicValueRef", "ValueRef", "ResolvedVal", "BasicBlockList",
1789 "BasicBlock", "InstructionList", "BBTerminatorInst", "JumpTable", "Inst",
1790 "PHIList", "ValueRefList", "IndexList", "OptTailCall", "InstVal",
1791 "OptVolatile", "MemoryInst", 0
1697 "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "ESAPINTVAL",
1698 "EUAPINTVAL", "LOCALVAL_ID", "GLOBALVAL_ID", "FPVAL", "VOID", "INTTYPE",
1699 "FLOAT", "DOUBLE", "LABEL", "TYPE", "LOCALVAR", "GLOBALVAR", "LABELSTR",
1700 "STRINGCONSTANT", "ATSTRINGCONSTANT", "ZEROINITIALIZER", "TRUETOK",
1701 "FALSETOK", "BEGINTOK", "ENDTOK", "DECLARE", "DEFINE", "GLOBAL",
1702 "CONSTANT", "SECTION", "ALIAS", "VOLATILE", "THREAD_LOCAL", "TO",
1703 "DOTDOTDOT", "NULL_TOK", "UNDEF", "INTERNAL", "LINKONCE", "WEAK",
1704 "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "OPAQUE",
1705 "EXTERNAL", "TARGET", "TRIPLE", "ALIGN", "DEPLIBS", "CALL", "TAIL",
1706 "ASM_TOK", "MODULE", "SIDEEFFECT", "CC_TOK", "CCC_TOK", "FASTCC_TOK",
1707 "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT",
1708 "RET", "BR", "SWITCH", "INVOKE", "UNWIND", "UNREACHABLE", "ADD", "SUB",
1709 "MUL", "UDIV", "SDIV", "FDIV", "UREM", "SREM", "FREM", "AND", "OR",
1710 "XOR", "SHL", "LSHR", "ASHR", "ICMP", "FCMP", "EQ", "NE", "SLT", "SGT",
1711 "SLE", "SGE", "ULT", "UGT", "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT",
1712 "OLE", "OGE", "ORD", "UNO", "UEQ", "UNE", "MALLOC", "ALLOCA", "FREE",
1713 "LOAD", "STORE", "GETELEMENTPTR", "TRUNC", "ZEXT", "SEXT", "FPTRUNC",
1714 "FPEXT", "BITCAST", "UITOFP", "SITOFP", "FPTOUI", "FPTOSI", "INTTOPTR",
1715 "PTRTOINT", "PHI_TOK", "SELECT", "VAARG", "EXTRACTELEMENT",
1716 "INSERTELEMENT", "SHUFFLEVECTOR", "NORETURN", "INREG", "SRET",
1717 "NOUNWIND", "DEFAULT", "HIDDEN", "'='", "','", "'*'", "'\\\\'", "'('",
1718 "')'", "'['", "'x'", "']'", "'<'", "'>'", "'{'", "'}'", "'c'",
1719 "$accept", "ArithmeticOps", "LogicalOps", "CastOps", "IPredicates",
1720 "FPredicates", "IntType", "FPType", "LocalName", "OptLocalName",
1721 "OptLocalAssign", "GlobalName", "OptGlobalAssign", "GlobalAssign",
1722 "GVInternalLinkage", "GVExternalLinkage", "GVVisibilityStyle",
1723 "FunctionDeclareLinkage", "FunctionDefineLinkage", "AliasLinkage",
1724 "OptCallingConv", "ParamAttr", "OptParamAttrs", "FuncAttr",
1725 "OptFuncAttrs", "OptAlign", "OptCAlign", "SectionString", "OptSection",
1726 "GlobalVarAttributes", "GlobalVarAttribute", "PrimType", "Types",
1727 "ArgType", "ResultTypes", "ArgTypeList", "ArgTypeListI", "TypeListI",
1728 "ConstVal", "ConstExpr", "ConstVector", "GlobalType", "ThreadLocal",
1729 "AliaseeRef", "Module", "DefinitionList", "Definition", "@1", "@2",
1730 "@3", "@4", "@5", "AsmBlock", "TargetDefinition", "LibrariesDefinition",
1731 "LibList", "ArgListH", "ArgList", "FunctionHeaderH", "BEGIN",
1732 "FunctionHeader", "END", "Function", "FunctionProto", "OptSideEffect",
1733 "ConstValueRef", "SymbolicValueRef", "ValueRef", "ResolvedVal",
1734 "BasicBlockList", "BasicBlock", "InstructionList", "BBTerminatorInst",
1735 "JumpTable", "Inst", "PHIList", "ValueRefList", "IndexList",
1736 "OptTailCall", "InstVal", "OptVolatile", "MemoryInst", 0
17921737 };
17931738 #endif
17941739
17951740 # ifdef YYPRINT
17961741 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
17971742 token YYLEX-NUM. */
1798 static const unsigned short int yytoknum[] =
1743 static const unsigned short yytoknum[] =
17991744 {
18001745 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
18011746 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
18881833 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
18891834 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
18901835 means the default is an error. */
1891 static const unsigned short int yydefact[] =
1836 static const unsigned short yydefact[] =
18921837 {
18931838 67, 58, 64, 59, 65, 192, 190, 0, 0, 0,
18941839 0, 0, 0, 77, 66, 0, 67, 188, 80, 83,
19511896 };
19521897
19531898 /* YYDEFGOTO[NTERM-NUM]. */
1954 static const short int yydefgoto[] =
1899 static const short yydefgoto[] =
19551900 {
19561901 -1, 250, 251, 252, 276, 293, 150, 151, 73, 497,
19571902 11, 74, 13, 14, 38, 39, 40, 45, 51, 111,
19671912 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
19681913 STATE-NUM. */
19691914 #define YYPACT_NINF -472
1970 static const short int yypact[] =
1915 static const short yypact[] =
19711916 {
19721917 50, -472, -472, -472, -472, -472, -472, -20, -110, 93,
19731918 -64, 160, 68, 14, -472, 185, 203, -472, 77, 199,
20301975 };
20311976
20321977 /* YYPGOTO[NTERM-NUM]. */
2033 static const short int yypgoto[] =
1978 static const short yypgoto[] =
20341979 {
20351980 -472, 401, 404, 405, 292, 294, -161, -472, 0, 8,
20361981 443, 9, -472, -472, -472, -472, 44, -472, -472, -472,
20461991 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
20471992 positive, shift that token. If negative, reduce the rule which
20481993 number is the opposite. If zero, do what YYDEFACT says.
2049 If YYTABLE_NINF, syntax error. */
1994 If YYTABLE_NINF, parse error. */
20501995 #define YYTABLE_NINF -188
2051 static const short int yytable[] =
1996 static const short yytable[] =
20521997 {
20531998 10, 76, 253, 264, 322, 459, 228, 155, 263, 12,
20541999 99, 387, 370, 254, 263, 387, 10, 156, 265, 296,
22132158 206
22142159 };
22152160
2216 static const short int yycheck[] =
2161 static const short yycheck[] =
22172162 {
22182163 0, 26, 152, 164, 224, 414, 145, 121, 11, 0,
22192164 4, 318, 295, 152, 11, 322, 16, 24, 165, 187,
24422387 14, 14, 137, 217, 217, 14, 67, 217, 14, 217
24432388 };
24442389
2390 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
2391 # define YYSIZE_T __SIZE_TYPE__
2392 #endif
2393 #if ! defined (YYSIZE_T) && defined (size_t)
2394 # define YYSIZE_T size_t
2395 #endif
2396 #if ! defined (YYSIZE_T)
2397 # if defined (__STDC__) || defined (__cplusplus)
2398 # include /* INFRINGES ON USER NAME SPACE */
2399 # define YYSIZE_T size_t
2400 # endif
2401 #endif
2402 #if ! defined (YYSIZE_T)
2403 # define YYSIZE_T unsigned int
2404 #endif
2405
24452406 #define yyerrok (yyerrstatus = 0)
24462407 #define yyclearin (yychar = YYEMPTY)
2447 #define YYEMPTY (-2)
2408 #define YYEMPTY -2
24482409 #define YYEOF 0
24492410
24502411 #define YYACCEPT goto yyacceptlab
24512412 #define YYABORT goto yyabortlab
2452 #define YYERROR goto yyerrorlab
2453
2413 #define YYERROR goto yyerrlab1
24542414
24552415 /* Like YYERROR except do call yyerror. This remains here temporarily
24562416 to ease the transition to the new meaning of YYERROR, for GCC.
24662426 { \
24672427 yychar = (Token); \
24682428 yylval = (Value); \
2469 yytoken = YYTRANSLATE (yychar); \
2429 yychar1 = YYTRANSLATE (yychar); \
24702430 YYPOPSTACK; \
24712431 goto yybackup; \
24722432 } \
24732433 else \
2474 { \
2475 yyerror (YY_("syntax error: cannot back up")); \
2434 { \
2435 yyerror ("syntax error: cannot back up"); \
24762436 YYERROR; \
24772437 } \
24782438 while (0)
24792439
2480
24812440 #define YYTERROR 1
24822441 #define YYERRCODE 256
24832442
2484
2485 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
2486 If N is 0, then set CURRENT to the empty location which ends
2487 the previous symbol: RHS[0] (always defined). */
2488
2489 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
2443 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
2444 are run). */
2445
24902446 #ifndef YYLLOC_DEFAULT
2491 # define YYLLOC_DEFAULT(Current, Rhs, N) \
2492 do \
2493 if (N) \
2494 { \
2495 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
2496 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
2497 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
2498 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
2499 } \
2500 else \
2501 { \
2502 (Current).first_line = (Current).last_line = \
2503 YYRHSLOC (Rhs, 0).last_line; \
2504 (Current).first_column = (Current).last_column = \
2505 YYRHSLOC (Rhs, 0).last_column; \
2506 } \
2507 while (0)
2447 # define YYLLOC_DEFAULT(Current, Rhs, N) \
2448 Current.first_line = Rhs[1].first_line; \
2449 Current.first_column = Rhs[1].first_column; \
2450 Current.last_line = Rhs[N].last_line; \
2451 Current.last_column = Rhs[N].last_column;
25082452 #endif
25092453
2510
2511 /* YY_LOCATION_PRINT -- Print the location on the stream.
2512 This macro was not mandated originally: define only if we know
2513 we won't break user code: when these are the locations we know. */
2514
2515 #ifndef YY_LOCATION_PRINT
2516 # if YYLTYPE_IS_TRIVIAL
2517 # define YY_LOCATION_PRINT(File, Loc) \
2518 fprintf (File, "%d.%d-%d.%d", \
2519 (Loc).first_line, (Loc).first_column, \
2520 (Loc).last_line, (Loc).last_column)
2521 # else
2522 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
2523 # endif
2524 #endif
2525
2526
25272454 /* YYLEX -- calling `yylex' with the right arguments. */
25282455
2529 #ifdef YYLEX_PARAM
2530 # define YYLEX yylex (YYLEX_PARAM)
2531 #else
2532 # define YYLEX yylex ()
2533 #endif
2456 #define YYLEX yylex ()
25342457
25352458 /* Enable debugging if requested. */
25362459 #if YYDEBUG
25452468 if (yydebug) \
25462469 YYFPRINTF Args; \
25472470 } while (0)
2548
2549 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
2550 do { \
2551 if (yydebug) \
2552 { \
2553 YYFPRINTF (stderr, "%s ", Title); \
2554 yysymprint (stderr, \
2555 Type, Value); \
2556 YYFPRINTF (stderr, "\n"); \
2557 } \
2471 # define YYDSYMPRINT(Args) \
2472 do { \
2473 if (yydebug) \
2474 yysymprint Args; \
25582475 } while (0)
2559
2560 /*------------------------------------------------------------------.
2561 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
2562 | TOP (included). |
2563 `------------------------------------------------------------------*/
2564
2565 #if defined (__STDC__) || defined (__cplusplus)
2566 static void
2567 yy_stack_print (short int *bottom, short int *top)
2568 #else
2569 static void
2570 yy_stack_print (bottom, top)
2571 short int *bottom;
2572 short int *top;
2573 #endif
2574 {
2575 YYFPRINTF (stderr, "Stack now");
2576 for (/* Nothing. */; bottom <= top; ++bottom)
2577 YYFPRINTF (stderr, " %d", *bottom);
2578 YYFPRINTF (stderr, "\n");
2579 }
2580
2581 # define YY_STACK_PRINT(Bottom, Top) \
2582 do { \
2583 if (yydebug) \
2584 yy_stack_print ((Bottom), (Top)); \
2585 } while (0)
2586
2587
2588 /*------------------------------------------------.
2589 | Report that the YYRULE is going to be reduced. |
2590 `------------------------------------------------*/
2591
2592 #if defined (__STDC__) || defined (__cplusplus)
2593 static void
2594 yy_reduce_print (int yyrule)
2595 #else
2596 static void
2597 yy_reduce_print (yyrule)
2598 int yyrule;
2599 #endif
2600 {
2601 int yyi;
2602 unsigned long int yylno = yyrline[yyrule];
2603 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
2604 yyrule - 1, yylno);
2605 /* Print the symbols being reduced, and their result. */
2606 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
2607 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
2608 YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
2609 }
2610
2611 # define YY_REDUCE_PRINT(Rule) \
2612 do { \
2613 if (yydebug) \
2614 yy_reduce_print (Rule); \
2615 } while (0)
2616
26172476 /* Nonzero means print parse trace. It is left uninitialized so that
26182477 multiple parsers can coexist. */
26192478 int yydebug;
26202479 #else /* !YYDEBUG */
26212480 # define YYDPRINTF(Args)
2622 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
2623 # define YY_STACK_PRINT(Bottom, Top)
2624 # define YY_REDUCE_PRINT(Rule)
2481 # define YYDSYMPRINT(Args)
26252482 #endif /* !YYDEBUG */
2626
26272483
26282484 /* YYINITDEPTH -- initial size of the parser's stacks. */
26292485 #ifndef YYINITDEPTH
26342490 if the built-in stack extension method is used).
26352491
26362492 Do not make this value too large; the results are undefined if
2637 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
2493 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
26382494 evaluated with infinite-precision integer arithmetic. */
2495
2496 #if YYMAXDEPTH == 0
2497 # undef YYMAXDEPTH
2498 #endif
26392499
26402500 #ifndef YYMAXDEPTH
26412501 # define YYMAXDEPTH 10000
26582518 const char *yystr;
26592519 # endif
26602520 {
2661 const char *yys = yystr;
2521 register const char *yys = yystr;
26622522
26632523 while (*yys++ != '\0')
26642524 continue;
26832543 const char *yysrc;
26842544 # endif
26852545 {
2686 char *yyd = yydest;
2687 const char *yys = yysrc;
2546 register char *yyd = yydest;
2547 register const char *yys = yysrc;
26882548
26892549 while ((*yyd++ = *yys++) != '\0')
26902550 continue;
26942554 # endif
26952555 # endif
26962556
2697 # ifndef yytnamerr
2698 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
2699 quotes and backslashes, so that it's suitable for yyerror. The
2700 heuristic is that double-quoting is unnecessary unless the string
2701 contains an apostrophe, a comma, or backslash (other than
2702 backslash-backslash). YYSTR is taken from yytname. If YYRES is
2703 null, do not copy; instead, return the length of what the result
2704 would have been. */
2705 static YYSIZE_T
2706 yytnamerr (char *yyres, const char *yystr)
2707 {
2708 if (*yystr == '"')
2709 {
2710 size_t yyn = 0;
2711 char const *yyp = yystr;
2712
2713 for (;;)
2714 switch (*++yyp)
2715 {
2716 case '\'':
2717 case ',':
2718 goto do_not_strip_quotes;
2719
2720 case '\\':
2721 if (*++yyp != '\\')
2722 goto do_not_strip_quotes;
2723 /* Fall through. */
2724 default:
2725 if (yyres)
2726 yyres[yyn] = *yyp;
2727 yyn++;
2728 break;
2729
2730 case '"':
2731 if (yyres)
2732 yyres[yyn] = '\0';
2733 return yyn;
2734 }
2735 do_not_strip_quotes: ;
2736 }
2737
2738 if (! yyres)
2739 return yystrlen (yystr);
2740
2741 return yystpcpy (yyres, yystr) - yyres;
2742 }
2743 # endif
2744
2745 #endif /* YYERROR_VERBOSE */
2557 #endif /* !YYERROR_VERBOSE */
27462558
27472559
27482560
27492561 #if YYDEBUG
2750 /*--------------------------------.
2751 | Print this symbol on YYOUTPUT. |
2752 `--------------------------------*/
2753
2562 /*-----------------------------.
2563 | Print this symbol on YYOUT. |
2564 `-----------------------------*/
2565
2566 static void
27542567 #if defined (__STDC__) || defined (__cplusplus)
2755 static void
2756 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
2568 yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue)
27572569 #else
2758 static void
2759 yysymprint (yyoutput, yytype, yyvaluep)
2760 FILE *yyoutput;
2570 yysymprint (yyout, yytype, yyvalue)
2571 FILE* yyout;
27612572 int yytype;
2762 YYSTYPE *yyvaluep;
2573 YYSTYPE yyvalue;
27632574 #endif
27642575 {
27652576 /* Pacify ``unused variable'' warnings. */
2766 (void) yyvaluep;
2577 (void) yyvalue;
27672578
27682579 if (yytype < YYNTOKENS)
2769 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
2580 {
2581 YYFPRINTF (yyout, "token %s (", yytname[yytype]);
2582 # ifdef YYPRINT
2583 YYPRINT (yyout, yytoknum[yytype], yyvalue);
2584 # endif
2585 }
27702586 else
2771 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
2772
2773
2774 # ifdef YYPRINT
2775 if (yytype < YYNTOKENS)
2776 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
2777 # endif
2587 YYFPRINTF (yyout, "nterm %s (", yytname[yytype]);
2588
27782589 switch (yytype)
27792590 {
27802591 default:
27812592 break;
27822593 }
2783 YYFPRINTF (yyoutput, ")");
2594 YYFPRINTF (yyout, ")");
27842595 }
2785
2786 #endif /* ! YYDEBUG */
2596 #endif /* YYDEBUG. */
2597
2598
27872599 /*-----------------------------------------------.
27882600 | Release the memory associated to this symbol. |
27892601 `-----------------------------------------------*/
27902602
2603 static void
27912604 #if defined (__STDC__) || defined (__cplusplus)
2792 static void
2793 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
2605 yydestruct (int yytype, YYSTYPE yyvalue)
27942606 #else
2795 static void
2796 yydestruct (yymsg, yytype, yyvaluep)
2797 const char *yymsg;
2607 yydestruct (yytype, yyvalue)
27982608 int yytype;
2799 YYSTYPE *yyvaluep;
2609 YYSTYPE yyvalue;
28002610 #endif
28012611 {
28022612 /* Pacify ``unused variable'' warnings. */
2803 (void) yyvaluep;
2804
2805 if (!yymsg)
2806 yymsg = "Deleting";
2807 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2613 (void) yyvalue;
28082614
28092615 switch (yytype)
28102616 {
2811
28122617 default:
28132618 break;
28142619 }
28152620 }
2621
28162622
28172623
2818 /* Prevent warnings from -Wmissing-prototypes. */
2624 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
2625 into yyparse. The argument should have type void *.
2626 It should actually point to an object.
2627 Grammar actions can access the variable by casting it
2628 to the proper pointer type. */
28192629
28202630 #ifdef YYPARSE_PARAM
28212631 # if defined (__STDC__) || defined (__cplusplus)
2822 int yyparse (void *YYPARSE_PARAM);
2632 # define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
2633 # define YYPARSE_PARAM_DECL
28232634 # else
2824 int yyparse ();
2635 # define YYPARSE_PARAM_ARG YYPARSE_PARAM
2636 # define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
28252637 # endif
2826 #else /* ! YYPARSE_PARAM */
2827 #if defined (__STDC__) || defined (__cplusplus)
2638 #else /* !YYPARSE_PARAM */
2639 # define YYPARSE_PARAM_ARG
2640 # define YYPARSE_PARAM_DECL
2641 #endif /* !YYPARSE_PARAM */
2642
2643 /* Prevent warning if -Wstrict-prototypes. */
2644 #ifdef __GNUC__
2645 # ifdef YYPARSE_PARAM
2646 int yyparse (void *);
2647 # else
28282648 int yyparse (void);
2829 #else
2830 int yyparse ();
2649 # endif
28312650 #endif
2832 #endif /* ! YYPARSE_PARAM */
2833
2834
2835
2836 /* The look-ahead symbol. */
2651
2652
2653 /* The lookahead symbol. */
28372654 int yychar;
28382655
2839 /* The semantic value of the look-ahead symbol. */
2656 /* The semantic value of the lookahead symbol. */
28402657 YYSTYPE yylval;
28412658
2842 /* Number of syntax errors so far. */
2659 /* Number of parse errors so far. */
28432660 int yynerrs;
28442661
28452662
2846
2847 /*----------.
2848 | yyparse. |
2849 `----------*/
2850
2851 #ifdef YYPARSE_PARAM
2852 # if defined (__STDC__) || defined (__cplusplus)
2853 int yyparse (void *YYPARSE_PARAM)
2854 # else
2855 int yyparse (YYPARSE_PARAM)
2856 void *YYPARSE_PARAM;
2857 # endif
2858 #else /* ! YYPARSE_PARAM */
2859 #if defined (__STDC__) || defined (__cplusplus)
28602663 int
2861 yyparse (void)
2862 #else
2863 int
2864 yyparse ()
2865
2866 #endif
2867 #endif
2664 yyparse (YYPARSE_PARAM_ARG)
2665 YYPARSE_PARAM_DECL
28682666 {
28692667
2870 int yystate;
2871 int yyn;
2668 register int yystate;
2669 register int yyn;
28722670 int yyresult;
28732671 /* Number of tokens to shift before error messages enabled. */
28742672 int yyerrstatus;
2875 /* Look-ahead token as an internal (translated) token number. */
2876 int yytoken = 0;
2673 /* Lookahead token as an internal (translated) token number. */
2674 int yychar1 = 0;
28772675
28782676 /* Three stacks and their tools:
28792677 `yyss': related to states,
28842682 to reallocate them elsewhere. */
28852683
28862684 /* The state stack. */
2887 short int yyssa[YYINITDEPTH];
2888 short int *yyss = yyssa;
2889 short int *yyssp;
2685 short yyssa[YYINITDEPTH];
2686 short *yyss = yyssa;
2687 register short *yyssp;
28902688
28912689 /* The semantic value stack. */
28922690 YYSTYPE yyvsa[YYINITDEPTH];
28932691 YYSTYPE *yyvs = yyvsa;
2894 YYSTYPE *yyvsp;
2692 register YYSTYPE *yyvsp;
28952693
28962694
28972695
29372735 yysetstate:
29382736 *yyssp = yystate;
29392737
2940 if (yyss + yystacksize - 1 <= yyssp)
2738 if (yyssp >= yyss + yystacksize - 1)
29412739 {
29422740 /* Get the current used size of the three stacks, in elements. */
29432741 YYSIZE_T yysize = yyssp - yyss + 1;
29482746 these so that the &'s don't force the real ones into
29492747 memory. */
29502748 YYSTYPE *yyvs1 = yyvs;
2951 short int *yyss1 = yyss;
2749 short *yyss1 = yyss;
29522750
29532751
29542752 /* Each stack pointer address is followed by the size of the
29552753 data in use in that stack, in bytes. This used to be a
29562754 conditional around just the two extra args, but that might
29572755 be undefined if yyoverflow is a macro. */
2958 yyoverflow (YY_("memory exhausted"),
2756 yyoverflow ("parser stack overflow",
29592757 &yyss1, yysize * sizeof (*yyssp),
29602758 &yyvs1, yysize * sizeof (*yyvsp),
29612759
29662764 }
29672765 #else /* no yyoverflow */
29682766 # ifndef YYSTACK_RELOCATE
2969 goto yyexhaustedlab;
2767 goto yyoverflowlab;
29702768 # else
29712769 /* Extend the stack our own way. */
2972 if (YYMAXDEPTH <= yystacksize)
2973 goto yyexhaustedlab;
2770 if (yystacksize >= YYMAXDEPTH)
2771 goto yyoverflowlab;
29742772 yystacksize *= 2;
2975 if (YYMAXDEPTH < yystacksize)
2773 if (yystacksize > YYMAXDEPTH)
29762774 yystacksize = YYMAXDEPTH;
29772775
29782776 {
2979 short int *yyss1 = yyss;
2777 short *yyss1 = yyss;
29802778 union yyalloc *yyptr =
29812779 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
29822780 if (! yyptr)
2983 goto yyexhaustedlab;
2781 goto yyoverflowlab;
29842782 YYSTACK_RELOCATE (yyss);
29852783 YYSTACK_RELOCATE (yyvs);
29862784
29982796 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
29992797 (unsigned long int) yystacksize));
30002798
3001 if (yyss + yystacksize - 1 <= yyssp)
2799 if (yyssp >= yyss + yystacksize - 1)
30022800 YYABORT;
30032801 }
30042802
30122810 yybackup:
30132811
30142812 /* Do appropriate processing given the current state. */
3015 /* Read a look-ahead token if we need one and don't already have one. */
2813 /* Read a lookahead token if we need one and don't already have one. */
30162814 /* yyresume: */
30172815
3018 /* First try to decide what to do without reference to look-ahead token. */
2816 /* First try to decide what to do without reference to lookahead token. */
30192817
30202818 yyn = yypact[yystate];
30212819 if (yyn == YYPACT_NINF)
30222820 goto yydefault;
30232821
3024 /* Not known => get a look-ahead token if don't already have one. */
3025
3026 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
2822 /* Not known => get a lookahead token if don't already have one. */
2823
2824 /* yychar is either YYEMPTY or YYEOF
2825 or a valid token in external form. */
2826
30272827 if (yychar == YYEMPTY)
30282828 {
30292829 YYDPRINTF ((stderr, "Reading a token: "));
30302830 yychar = YYLEX;
30312831 }
30322832
3033 if (yychar <= YYEOF)
3034 {
3035 yychar = yytoken = YYEOF;
2833 /* Convert token to internal form (in yychar1) for indexing tables with. */
2834
2835 if (yychar <= 0) /* This means end of input. */
2836 {
2837 yychar1 = 0;
2838 yychar = YYEOF; /* Don't call YYLEX any more. */
2839
30362840 YYDPRINTF ((stderr, "Now at end of input.\n"));
30372841 }
30382842 else
30392843 {
3040 yytoken = YYTRANSLATE (yychar);
3041 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2844 yychar1 = YYTRANSLATE (yychar);
2845
2846 /* We have to keep this `#if YYDEBUG', since we use variables
2847 which are defined only if `YYDEBUG' is set. */
2848 YYDPRINTF ((stderr, "Next token is "));
2849 YYDSYMPRINT ((stderr, yychar1, yylval));
2850 YYDPRINTF ((stderr, "\n"));
30422851 }
30432852
3044 /* If the proper action on seeing token YYTOKEN is to reduce or to
2853 /* If the proper action on seeing token YYCHAR1 is to reduce or to
30452854 detect an error, take that action. */
3046 yyn += yytoken;
3047 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2855 yyn += yychar1;
2856 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
30482857 goto yydefault;
30492858 yyn = yytable[yyn];
30502859 if (yyn <= 0)
30582867 if (yyn == YYFINAL)
30592868 YYACCEPT;
30602869
3061 /* Shift the look-ahead token. */
3062 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2870 /* Shift the lookahead token. */
2871 YYDPRINTF ((stderr, "Shifting token %d (%s), ",
2872 yychar, yytname[yychar1]));
30632873
30642874 /* Discard the token being shifted unless it is eof. */
30652875 if (yychar != YYEOF)
31052915 yyval = yyvsp[1-yylen];
31062916
31072917
3108 YY_REDUCE_PRINT (yyn);
2918
2919 #if YYDEBUG
2920 /* We have to keep this `#if YYDEBUG', since we use variables which
2921 are defined only if `YYDEBUG' is set. */
2922 if (yydebug)
2923 {
2924 int yyi;
2925
2926 YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
2927 yyn - 1, yyrline[yyn]);
2928
2929 /* Print the symbols being reduced, and their result. */
2930 for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)
2931 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
2932 YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
2933 }
2934 #endif
31092935 switch (yyn)
31102936 {
31112937 case 29:
3112 #line 1117 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3113 { (yyval.IPredicate) = ICmpInst::ICMP_EQ; ;}
2938 #line 1117 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
2939 { yyval.IPredicate = ICmpInst::ICMP_EQ; }
31142940 break;
31152941
31162942 case 30:
3117 #line 1117 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3118 { (yyval.IPredicate) = ICmpInst::ICMP_NE; ;}
2943 #line 1117 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
2944 { yyval.IPredicate = ICmpInst::ICMP_NE; }
31192945 break;
31202946
31212947 case 31:
3122 #line 1118 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3123 { (yyval.IPredicate) = ICmpInst::ICMP_SLT; ;}
2948 #line 1118 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
2949 { yyval.IPredicate = ICmpInst::ICMP_SLT; }
31242950 break;
31252951
31262952 case 32:
3127 #line 1118 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3128 { (yyval.IPredicate) = ICmpInst::ICMP_SGT; ;}
2953 #line 1118 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
2954 { yyval.IPredicate = ICmpInst::ICMP_SGT; }
31292955 break;
31302956
31312957 case 33:
3132 #line 1119 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3133 { (yyval.IPredicate) = ICmpInst::ICMP_SLE; ;}
2958 #line 1119 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
2959 { yyval.IPredicate = ICmpInst::ICMP_SLE; }
31342960 break;
31352961
31362962 case 34:
3137 #line 1119 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3138 { (yyval.IPredicate) = ICmpInst::ICMP_SGE; ;}
2963 #line 1119 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
2964 { yyval.IPredicate = ICmpInst::ICMP_SGE; }
31392965 break;
31402966
31412967 case 35:
3142 #line 1120 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3143 { (yyval.IPredicate) = ICmpInst::ICMP_ULT; ;}
2968 #line 1120 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
2969 { yyval.IPredicate = ICmpInst::ICMP_ULT; }
31442970 break;
31452971
31462972 case 36:
3147 #line 1120 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3148 { (yyval.IPredicate) = ICmpInst::ICMP_UGT; ;}
2973 #line 1120 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
2974 { yyval.IPredicate = ICmpInst::ICMP_UGT; }
31492975 break;
31502976
31512977 case 37:
3152 #line 1121 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3153 { (yyval.IPredicate) = ICmpInst::ICMP_ULE; ;}
2978 #line 1121 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
2979 { yyval.IPredicate = ICmpInst::ICMP_ULE; }
31542980 break;
31552981
31562982 case 38:
3157 #line 1121 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3158 { (yyval.IPredicate) = ICmpInst::ICMP_UGE; ;}
2983 #line 1121 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
2984 { yyval.IPredicate = ICmpInst::ICMP_UGE; }
31592985 break;
31602986
31612987 case 39:
3162 #line 1125 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3163 { (yyval.FPredicate) = FCmpInst::FCMP_OEQ; ;}
2988 #line 1125 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
2989 { yyval.FPredicate = FCmpInst::FCMP_OEQ; }
31642990 break;
31652991
31662992 case 40:
3167 #line 1125 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3168 { (yyval.FPredicate) = FCmpInst::FCMP_ONE; ;}
2993 #line 1125 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
2994 { yyval.FPredicate = FCmpInst::FCMP_ONE; }
31692995 break;
31702996
31712997 case 41:
3172 #line 1126 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3173 { (yyval.FPredicate) = FCmpInst::FCMP_OLT; ;}
2998 #line 1126 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
2999 { yyval.FPredicate = FCmpInst::FCMP_OLT; }
31743000 break;
31753001
31763002 case 42:
3177 #line 1126 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3178 { (yyval.FPredicate) = FCmpInst::FCMP_OGT; ;}
3003 #line 1126 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3004 { yyval.FPredicate = FCmpInst::FCMP_OGT; }
31793005 break;
31803006
31813007 case 43:
3182 #line 1127 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3183 { (yyval.FPredicate) = FCmpInst::FCMP_OLE; ;}
3008 #line 1127 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3009 { yyval.FPredicate = FCmpInst::FCMP_OLE; }
31843010 break;
31853011
31863012 case 44:
3187 #line 1127 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3188 { (yyval.FPredicate) = FCmpInst::FCMP_OGE; ;}
3013 #line 1127 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3014 { yyval.FPredicate = FCmpInst::FCMP_OGE; }
31893015 break;
31903016
31913017 case 45:
3192 #line 1128 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3193 { (yyval.FPredicate) = FCmpInst::FCMP_ORD; ;}
3018 #line 1128 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3019 { yyval.FPredicate = FCmpInst::FCMP_ORD; }
31943020 break;
31953021
31963022 case 46:
3197 #line 1128 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3198 { (yyval.FPredicate) = FCmpInst::FCMP_UNO; ;}
3023 #line 1128 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3024 { yyval.FPredicate = FCmpInst::FCMP_UNO; }
31993025 break;
32003026
32013027 case 47:
3202 #line 1129 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3203 { (yyval.FPredicate) = FCmpInst::FCMP_UEQ; ;}
3028 #line 1129 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3029 { yyval.FPredicate = FCmpInst::FCMP_UEQ; }
32043030 break;
32053031
32063032 case 48:
3207 #line 1129 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3208 { (yyval.FPredicate) = FCmpInst::FCMP_UNE; ;}
3033 #line 1129 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3034 { yyval.FPredicate = FCmpInst::FCMP_UNE; }
32093035 break;
32103036
32113037 case 49:
3212 #line 1130 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3213 { (yyval.FPredicate) = FCmpInst::FCMP_ULT; ;}
3038 #line 1130 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3039 { yyval.FPredicate = FCmpInst::FCMP_ULT; }
32143040 break;
32153041
32163042 case 50:
3217 #line 1130 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3218 { (yyval.FPredicate) = FCmpInst::FCMP_UGT; ;}
3043 #line 1130 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3044 { yyval.FPredicate = FCmpInst::FCMP_UGT; }
32193045 break;
32203046
32213047 case 51:
3222 #line 1131 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3223 { (yyval.FPredicate) = FCmpInst::FCMP_ULE; ;}
3048 #line 1131 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3049 { yyval.FPredicate = FCmpInst::FCMP_ULE; }
32243050 break;
32253051
32263052 case 52:
3227 #line 1131 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3228 { (yyval.FPredicate) = FCmpInst::FCMP_UGE; ;}
3053 #line 1131 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3054 { yyval.FPredicate = FCmpInst::FCMP_UGE; }
32293055 break;
32303056
32313057 case 53:
3232 #line 1132 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3233 { (yyval.FPredicate) = FCmpInst::FCMP_TRUE; ;}
3058 #line 1132 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3059 { yyval.FPredicate = FCmpInst::FCMP_TRUE; }
32343060 break;
32353061
32363062 case 54:
3237 #line 1133 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3238 { (yyval.FPredicate) = FCmpInst::FCMP_FALSE; ;}
3063 #line 1133 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3064 { yyval.FPredicate = FCmpInst::FCMP_FALSE; }
32393065 break;
32403066
32413067 case 61:
3242 #line 1142 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3243 { (yyval.StrVal) = 0; ;}
3068 #line 1142 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3069 { yyval.StrVal = 0; }
32443070 break;
32453071
32463072 case 62:
3247 #line 1146 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3248 {
3249 (yyval.StrVal) = (yyvsp[-1].StrVal);
3250 CHECK_FOR_ERROR
3251 ;}
3073 #line 1146 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3074 {
3075 yyval.StrVal = yyvsp[-1].StrVal;
3076 CHECK_FOR_ERROR
3077 }
32523078 break;
32533079
32543080 case 63:
3255 #line 1150 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3256 {
3257 (yyval.StrVal) = 0;
3258 CHECK_FOR_ERROR
3259 ;}
3081 #line 1150 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3082 {
3083 yyval.StrVal = 0;
3084 CHECK_FOR_ERROR
3085 }
32603086 break;
32613087
32623088 case 67:
3263 #line 1158 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3264 {
3265 (yyval.StrVal) = 0;
3266 CHECK_FOR_ERROR
3267 ;}
3089 #line 1158 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3090 {
3091 yyval.StrVal = 0;
3092 CHECK_FOR_ERROR
3093 }
32683094 break;
32693095
32703096 case 68:
3271 #line 1163 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3272 {
3273 (yyval.StrVal) = (yyvsp[-1].StrVal);
3274 CHECK_FOR_ERROR
3275 ;}
3097 #line 1163 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3098 {
3099 yyval.StrVal = yyvsp[-1].StrVal;
3100 CHECK_FOR_ERROR
3101 }
32763102 break;
32773103
32783104 case 69:
3279 #line 1169 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3280 { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
3105 #line 1169 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3106 { yyval.Linkage = GlobalValue::InternalLinkage; }
32813107 break;
32823108
32833109 case 70:
3284 #line 1170 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3285 { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
3110 #line 1170 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3111 { yyval.Linkage = GlobalValue::WeakLinkage; }
32863112 break;
32873113
32883114 case 71:
3289 #line 1171 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3290 { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
3115 #line 1171 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3116 { yyval.Linkage = GlobalValue::LinkOnceLinkage; }
32913117 break;
32923118
32933119 case 72:
3294 #line 1172 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3295 { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;}
3120 #line 1172 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3121 { yyval.Linkage = GlobalValue::AppendingLinkage; }
32963122 break;
32973123
32983124 case 73:
3299 #line 1173 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3300 { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
3125 #line 1173 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3126 { yyval.Linkage = GlobalValue::DLLExportLinkage; }
33013127 break;
33023128
33033129 case 74:
3304 #line 1177 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3305 { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
3130 #line 1177 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3131 { yyval.Linkage = GlobalValue::DLLImportLinkage; }
33063132 break;
33073133
33083134 case 75:
3309 #line 1178 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3310 { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
3135 #line 1178 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3136 { yyval.Linkage = GlobalValue::ExternalWeakLinkage; }
33113137 break;
33123138
33133139 case 76:
3314 #line 1179 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3315 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3140 #line 1179 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3141 { yyval.Linkage = GlobalValue::ExternalLinkage; }
33163142 break;
33173143
33183144 case 77:
3319 #line 1183 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3320 { (yyval.Visibility) = GlobalValue::DefaultVisibility; ;}
3145 #line 1183 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3146 { yyval.Visibility = GlobalValue::DefaultVisibility; }
33213147 break;
33223148
33233149 case 78:
3324 #line 1184 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3325 { (yyval.Visibility) = GlobalValue::DefaultVisibility; ;}
3150 #line 1184 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3151 { yyval.Visibility = GlobalValue::DefaultVisibility; }
33263152 break;
33273153
33283154 case 79:
3329 #line 1185 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3330 { (yyval.Visibility) = GlobalValue::HiddenVisibility; ;}
3155 #line 1185 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3156 { yyval.Visibility = GlobalValue::HiddenVisibility; }
33313157 break;
33323158
33333159 case 80:
3334 #line 1189 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3335 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3160 #line 1189 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3161 { yyval.Linkage = GlobalValue::ExternalLinkage; }
33363162 break;
33373163
33383164 case 81:
3339 #line 1190 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3340 { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
3165 #line 1190 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3166 { yyval.Linkage = GlobalValue::DLLImportLinkage; }
33413167 break;
33423168
33433169 case 82:
3344 #line 1191 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3345 { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
3170 #line 1191 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3171 { yyval.Linkage = GlobalValue::ExternalWeakLinkage; }
33463172 break;
33473173
33483174 case 83:
3349 #line 1195 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3350 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3175 #line 1195 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3176 { yyval.Linkage = GlobalValue::ExternalLinkage; }
33513177 break;
33523178
33533179 case 84:
3354 #line 1196 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3355 { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
3180 #line 1196 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3181 { yyval.Linkage = GlobalValue::InternalLinkage; }
33563182 break;
33573183
33583184 case 85:
3359 #line 1197 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3360 { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
3185 #line 1197 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3186 { yyval.Linkage = GlobalValue::LinkOnceLinkage; }
33613187 break;
33623188
33633189 case 86:
3364 #line 1198 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3365 { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
3190 #line 1198 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3191 { yyval.Linkage = GlobalValue::WeakLinkage; }
33663192 break;
33673193
33683194 case 87:
3369 #line 1199 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3370 { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
3195 #line 1199 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3196 { yyval.Linkage = GlobalValue::DLLExportLinkage; }
33713197 break;
33723198
33733199 case 88:
3374 #line 1203 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3375 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3200 #line 1203 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3201 { yyval.Linkage = GlobalValue::ExternalLinkage; }
33763202 break;
33773203
33783204 case 89:
3379 #line 1204 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3380 { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
3205 #line 1204 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3206 { yyval.Linkage = GlobalValue::WeakLinkage; }
33813207 break;
33823208
33833209 case 90:
3384 #line 1205 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3385 { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
3210 #line 1205 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3211 { yyval.Linkage = GlobalValue::InternalLinkage; }
33863212 break;
33873213
33883214 case 91:
3389 #line 1208 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3390 { (yyval.UIntVal) = CallingConv::C; ;}
3215 #line 1208 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3216 { yyval.UIntVal = CallingConv::C; }
33913217 break;
33923218
33933219 case 92:
3394 #line 1209 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3395 { (yyval.UIntVal) = CallingConv::C; ;}
3220 #line 1209 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3221 { yyval.UIntVal = CallingConv::C; }
33963222 break;
33973223
33983224 case 93:
3399 #line 1210 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3400 { (yyval.UIntVal) = CallingConv::Fast; ;}
3225 #line 1210 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3226 { yyval.UIntVal = CallingConv::Fast; }
34013227 break;
34023228
34033229 case 94:
3404 #line 1211 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3405 { (yyval.UIntVal) = CallingConv::Cold; ;}
3230 #line 1211 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3231 { yyval.UIntVal = CallingConv::Cold; }
34063232 break;
34073233
34083234 case 95:
3409 #line 1212 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3410 { (yyval.UIntVal) = CallingConv::X86_StdCall; ;}
3235 #line 1212 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3236 { yyval.UIntVal = CallingConv::X86_StdCall; }
34113237 break;
34123238
34133239 case 96:
3414 #line 1213 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3415 { (yyval.UIntVal) = CallingConv::X86_FastCall; ;}
3240 #line 1213 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3241 { yyval.UIntVal = CallingConv::X86_FastCall; }
34163242 break;
34173243
34183244 case 97:
3419 #line 1214 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3420 {
3421 if ((unsigned)(yyvsp[0].UInt64Val) != (yyvsp[0].UInt64Val))
3245 #line 1214 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3246 {
3247 if ((unsigned)yyvsp[0].UInt64Val != yyvsp[0].UInt64Val)
34223248 GEN_ERROR("Calling conv too large");
3423 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
3249 yyval.UIntVal = yyvsp[0].UInt64Val;
34243250 CHECK_FOR_ERROR
3425 ;}
3251 }
34263252 break;
34273253
34283254 case 98:
3429 #line 1221 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3430 { (yyval.ParamAttrs) = ParamAttr::ZExt; ;}
3255 #line 1221 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3256 { yyval.ParamAttrs = ParamAttr::ZExt; }
34313257 break;
34323258
34333259 case 99:
3434 #line 1222 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3435 { (yyval.ParamAttrs) = ParamAttr::SExt; ;}
3260 #line 1222 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3261 { yyval.ParamAttrs = ParamAttr::SExt; }
34363262 break;
34373263
34383264 case 100:
3439 #line 1223 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3440 { (yyval.ParamAttrs) = ParamAttr::InReg; ;}
3265 #line 1223 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3266 { yyval.ParamAttrs = ParamAttr::InReg; }
34413267 break;
34423268
34433269 case 101:
3444 #line 1224 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3445 { (yyval.ParamAttrs) = ParamAttr::StructRet; ;}
3270 #line 1224 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3271 { yyval.ParamAttrs = ParamAttr::StructRet; }
34463272 break;
34473273
34483274 case 102:
3449 #line 1227 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3450 { (yyval.ParamAttrs) = ParamAttr::None; ;}
3275 #line 1227 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3276 { yyval.ParamAttrs = ParamAttr::None; }
34513277 break;
34523278
34533279 case 103:
3454 #line 1228 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3455 {
3456 (yyval.ParamAttrs) = (yyvsp[-1].ParamAttrs) | (yyvsp[0].ParamAttrs);
3457 ;}
3280 #line 1228 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3281 {
3282 yyval.ParamAttrs = yyvsp[-1].ParamAttrs | yyvsp[0].ParamAttrs;
3283 }
34583284 break;
34593285
34603286 case 104:
3461 #line 1233 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3462 { (yyval.ParamAttrs) = ParamAttr::NoReturn; ;}
3287 #line 1233 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3288 { yyval.ParamAttrs = ParamAttr::NoReturn; }
34633289 break;
34643290
34653291 case 105:
3466 #line 1234 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3467 { (yyval.ParamAttrs) = ParamAttr::NoUnwind; ;}
3292 #line 1234 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3293 { yyval.ParamAttrs = ParamAttr::NoUnwind; }
34683294 break;
34693295
34703296 case 107:
3471 #line 1238 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3472 { (yyval.ParamAttrs) = ParamAttr::None; ;}
3297 #line 1238 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3298 { yyval.ParamAttrs = ParamAttr::None; }
34733299 break;
34743300
34753301 case 108:
3476 #line 1239 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3477 {
3478 (yyval.ParamAttrs) = (yyvsp[-1].ParamAttrs) | (yyvsp[0].ParamAttrs);
3479 ;}
3302 #line 1239 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3303 {
3304 yyval.ParamAttrs = yyvsp[-1].ParamAttrs | yyvsp[0].ParamAttrs;
3305 }
34803306 break;
34813307
34823308 case 109:
3483 #line 1246 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3484 { (yyval.UIntVal) = 0; ;}
3309 #line 1246 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3310 { yyval.UIntVal = 0; }
34853311 break;
34863312
34873313 case 110:
3488 #line 1247 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3489 {
3490 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
3491 if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
3314 #line 1247 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3315 {
3316 yyval.UIntVal = yyvsp[0].UInt64Val;
3317 if (yyval.UIntVal != 0 && !isPowerOf2_32(yyval.UIntVal))
34923318 GEN_ERROR("Alignment must be a power of two");
34933319 CHECK_FOR_ERROR
3494 ;}
3320 }
34953321 break;
34963322
34973323 case 111:
3498 #line 1253 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3499 { (yyval.UIntVal) = 0; ;}
3324 #line 1253 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3325 { yyval.UIntVal = 0; }
35003326 break;
35013327
35023328 case 112:
3503 #line 1254 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3504 {
3505 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
3506 if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
3329 #line 1254 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3330 {
3331 yyval.UIntVal = yyvsp[0].UInt64Val;
3332 if (yyval.UIntVal != 0 && !isPowerOf2_32(yyval.UIntVal))
35073333 GEN_ERROR("Alignment must be a power of two");
35083334 CHECK_FOR_ERROR
3509 ;}
3335 }
35103336 break;
35113337
35123338 case 113:
3513 #line 1262 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3514 {
3515 for (unsigned i = 0, e = strlen((yyvsp[0].StrVal)); i != e; ++i)
3516 if ((yyvsp[0].StrVal)[i] == '"' || (yyvsp[0].StrVal)[i] == '\\')
3339 #line 1262 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3340 {
3341 for (unsigned i = 0, e = strlen(yyvsp[0].StrVal); i != e; ++i)
3342 if (yyvsp[0].StrVal[i] == '"' || yyvsp[0].StrVal[i] == '\\')
35173343 GEN_ERROR("Invalid character in section name");
3518 (yyval.StrVal) = (yyvsp[0].StrVal);
3344 yyval.StrVal = yyvsp[0].StrVal;
35193345 CHECK_FOR_ERROR
3520 ;}
3346 }
35213347 break;
35223348
35233349 case 114:
3524 #line 1270 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3525 { (yyval.StrVal) = 0; ;}
3350 #line 1270 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3351 { yyval.StrVal = 0; }
35263352 break;
35273353
35283354 case 115:
3529 #line 1271 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3530 { (yyval.StrVal) = (yyvsp[0].StrVal); ;}
3355 #line 1271 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3356 { yyval.StrVal = yyvsp[0].StrVal; }
35313357 break;
35323358
35333359 case 116:
3534 #line 1276 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3535 {;}
3360 #line 1276 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3361 {}
35363362 break;
35373363
35383364 case 117:
3539 #line 1277 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3540 {;}
3365 #line 1277 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3366 {}
35413367 break;
35423368
35433369 case 118:
3544 #line 1278 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3545 {
3546 CurGV->setSection((yyvsp[0].StrVal));
3547 free((yyvsp[0].StrVal));
3548 CHECK_FOR_ERROR
3549 ;}
3370 #line 1278 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3371 {
3372 CurGV->setSection(yyvsp[0].StrVal);
3373 free(yyvsp[0].StrVal);
3374 CHECK_FOR_ERROR
3375 }
35503376 break;
35513377
35523378 case 119:
3553 #line 1283 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3554 {
3555 if ((yyvsp[0].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[0].UInt64Val)))
3379 #line 1283 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3380 {
3381 if (yyvsp[0].UInt64Val != 0 && !isPowerOf2_32(yyvsp[0].UInt64Val))
35563382 GEN_ERROR("Alignment must be a power of two");
3557 CurGV->setAlignment((yyvsp[0].UInt64Val));
3558 CHECK_FOR_ERROR
3559 ;}
3383 CurGV->setAlignment(yyvsp[0].UInt64Val);
3384 CHECK_FOR_ERROR
3385 }
35603386 break;
35613387
35623388 case 124:
3563 #line 1299 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3564 {
3565 (yyval.TypeVal) = new PATypeHolder(OpaqueType::get());
3566 CHECK_FOR_ERROR
3567 ;}
3389 #line 1299 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3390 {
3391 yyval.TypeVal = new PATypeHolder(OpaqueType::get());
3392 CHECK_FOR_ERROR
3393 }
35683394 break;
35693395
35703396 case 125:
3571 #line 1303 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3572 {
3573 (yyval.TypeVal) = new PATypeHolder((yyvsp[0].PrimType));
3574 CHECK_FOR_ERROR
3575 ;}
3397 #line 1303 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3398 {
3399 yyval.TypeVal = new PATypeHolder(yyvsp[0].PrimType);
3400 CHECK_FOR_ERROR
3401 }
35763402 break;
35773403
35783404 case 126:
3579 #line 1307 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3405 #line 1307 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
35803406 { // Pointer type?
3581 if (*(yyvsp[-1].TypeVal) == Type::LabelTy)
3407 if (*yyvsp[-1].TypeVal == Type::LabelTy)
35823408 GEN_ERROR("Cannot form a pointer to a basic block");
3583 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(PointerType::get(*(yyvsp[-1].TypeVal))));
3584 delete (yyvsp[-1].TypeVal);
3585 CHECK_FOR_ERROR
3586 ;}
3409 yyval.TypeVal = new PATypeHolder(HandleUpRefs(PointerType::get(*yyvsp[-1].TypeVal)));
3410 delete yyvsp[-1].TypeVal;
3411 CHECK_FOR_ERROR
3412 }
35873413 break;
35883414
35893415 case 127:
3590 #line 1314 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3416 #line 1314 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
35913417 { // Named types are also simple types...
3592 const Type* tmp = getTypeVal((yyvsp[0].ValIDVal));
3593 CHECK_FOR_ERROR
3594 (yyval.TypeVal) = new PATypeHolder(tmp);
3595 ;}
3418 const Type* tmp = getTypeVal(yyvsp[0].ValIDVal);
3419 CHECK_FOR_ERROR
3420 yyval.TypeVal = new PATypeHolder(tmp);
3421 }
35963422 break;
35973423
35983424 case 128:
3599 #line 1319 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3425 #line 1319 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
36003426 { // Type UpReference
3601 if ((yyvsp[0].UInt64Val) > (uint64_t)~0U) GEN_ERROR("Value out of range");
3427 if (yyvsp[0].UInt64Val > (uint64_t)~0U) GEN_ERROR("Value out of range");
36023428 OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder
3603 UpRefs.push_back(UpRefRecord((unsigned)(yyvsp[0].UInt64Val), OT)); // Add to vector...
3604 (yyval.TypeVal) = new PATypeHolder(OT);
3429 UpRefs.push_back(UpRefRecord((unsigned)yyvsp[0].UInt64Val, OT)); // Add to vector...
3430 yyval.TypeVal = new PATypeHolder(OT);
36053431 UR_OUT("New Upreference!\n");
36063432 CHECK_FOR_ERROR
3607 ;}
3433 }
36083434 break;
36093435
36103436 case 129:
3611 #line 1327 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3437 #line 1327 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
36123438 {
36133439 std::vector Params;
36143440 ParamAttrsVector Attrs;
3615 if ((yyvsp[0].ParamAttrs) != ParamAttr::None) {
3616 ParamAttrsWithIndex X; X.index = 0; X.attrs = (yyvsp[0].ParamAttrs);
3441 if (yyvsp[0].ParamAttrs != ParamAttr::None) {
3442 ParamAttrsWithIndex X; X.index = 0; X.attrs = yyvsp[0].ParamAttrs;
36173443 Attrs.push_back(X);
36183444 }
36193445 unsigned index = 1;
3620 TypeWithAttrsList::iterator I = (yyvsp[-2].TypeWithAttrsList)->begin(), E = (yyvsp[-2].TypeWithAttrsList)->end();
3446 TypeWithAttrsList::iterator I = yyvsp[-2].TypeWithAttrsList->begin(), E = yyvsp[-2].TypeWithAttrsList->end();
36213447 for (; I != E; ++I, ++index) {
36223448 const Type *Ty = I->Ty->get();
36233449 Params.push_back(Ty);
36333459 ParamAttrsList *ActualAttrs = 0;
36343460 if (!Attrs.empty())
36353461 ActualAttrs = ParamAttrsList::get(Attrs);
3636 FunctionType *FT = FunctionType::get(*(yyvsp[-4].TypeVal), Params, isVarArg, ActualAttrs);
3637 delete (yyvsp[-2].TypeWithAttrsList); // Delete the argument list
3638 delete (yyvsp[-4].TypeVal); // Delete the return type handle
3639 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(FT));
3640 CHECK_FOR_ERROR
3641 ;}
3462 FunctionType *FT = FunctionType::get(*yyvsp[-4].TypeVal, Params, isVarArg, ActualAttrs);
3463 delete yyvsp[-2].TypeWithAttrsList; // Delete the argument list
3464 delete yyvsp[-4].TypeVal; // Delete the return type handle
3465 yyval.TypeVal = new PATypeHolder(HandleUpRefs(FT));
3466 CHECK_FOR_ERROR
3467 }
36423468 break;
36433469
36443470 case 130:
3645 #line 1357 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3471 #line 1357 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
36463472 {
36473473 std::vector Params;
36483474 ParamAttrsVector Attrs;
3649 if ((yyvsp[0].ParamAttrs) != ParamAttr::None) {
3650 ParamAttrsWithIndex X; X.index = 0; X.attrs = (yyvsp[0].ParamAttrs);
3475 if (yyvsp[0].ParamAttrs != ParamAttr::None) {
3476 ParamAttrsWithIndex X; X.index = 0; X.attrs = yyvsp[0].ParamAttrs;
36513477 Attrs.push_back(X);
36523478 }
3653 TypeWithAttrsList::iterator I = (yyvsp[-2].TypeWithAttrsList)->begin(), E = (yyvsp[-2].TypeWithAttrsList)->end();
3479 TypeWithAttrsList::iterator I = yyvsp[-2].TypeWithAttrsList->begin(), E = yyvsp[-2].TypeWithAttrsList->end();
36543480 unsigned index = 1;
36553481 for ( ; I != E; ++I, ++index) {
36563482 const Type* Ty = I->Ty->get();
36683494 if (!Attrs.empty())
36693495 ActualAttrs = ParamAttrsList::get(Attrs);
36703496
3671 FunctionType *FT = FunctionType::get((yyvsp[-4].PrimType), Params, isVarArg, ActualAttrs);
3672 delete (yyvsp[-2].TypeWithAttrsList); // Delete the argument list
3673 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(FT));
3674 CHECK_FOR_ERROR
3675 ;}
3497 FunctionType *FT = FunctionType::get(yyvsp[-4].PrimType, Params, isVarArg, ActualAttrs);
3498 delete yyvsp[-2].TypeWithAttrsList; // Delete the argument list
3499 yyval.TypeVal = new PATypeHolder(HandleUpRefs(FT));
3500 CHECK_FOR_ERROR
3501 }
36763502 break;
36773503
36783504 case 131:
3679 #line 1388 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3505 #line 1388 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
36803506 { // Sized array type?
3681 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(ArrayType::get(*(yyvsp[-1].TypeVal), (unsigned)(yyvsp[-3].UInt64Val))));
3682 delete (yyvsp[-1].TypeVal);
3683 CHECK_FOR_ERROR
3684 ;}
3507 yyval.TypeVal = new PATypeHolder(HandleUpRefs(ArrayType::get(*yyvsp[-1].TypeVal, (unsigned)yyvsp[-3].UInt64Val)));
3508 delete yyvsp[-1].TypeVal;
3509 CHECK_FOR_ERROR
3510 }
36853511 break;
36863512
36873513 case 132:
3688 #line 1393 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3514 #line 1393 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
36893515 { // Vector type?
3690 const llvm::Type* ElemTy = (yyvsp[-1].TypeVal)->get();
3691 if ((unsigned)(yyvsp[-3].UInt64Val) != (yyvsp[-3].UInt64Val))
3516 const llvm::Type* ElemTy = yyvsp[-1].TypeVal->get();
3517 if ((unsigned)yyvsp[-3].UInt64Val != yyvsp[-3].UInt64Val)
36923518 GEN_ERROR("Unsigned result not equal to signed result");
36933519 if (!ElemTy->isFloatingPoint() && !ElemTy->isInteger())
36943520 GEN_ERROR("Element type of a VectorType must be primitive");
3695 if (!isPowerOf2_32((yyvsp[-3].UInt64Val)))
3521 if (!isPowerOf2_32(yyvsp[-3].UInt64Val))
36963522 GEN_ERROR("Vector length should be a power of 2");
3697 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(VectorType::get(*(yyvsp[-1].TypeVal), (unsigned)(yyvsp[-3].UInt64Val))));
3698 delete (yyvsp[-1].TypeVal);
3523 yyval.TypeVal = new PATypeHolder(HandleUpRefs(VectorType::get(*yyvsp[-1].TypeVal, (unsigned)yyvsp[-3].UInt64Val)));
3524 delete yyvsp[-1].TypeVal;
36993525 CHECK_FOR_ERROR
3700 ;}
3526 }
37013527 break;
37023528
37033529 case 133:
3704 #line 1405 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3530 #line 1405 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
37053531 { // Structure type?
37063532 std::vector Elements;
3707 for (std::list::iterator I = (yyvsp[-1].TypeList)->begin(),
3708 E = (yyvsp[-1].TypeList)->end(); I != E; ++I)
3533 for (std::list::iterator I = yyvsp[-1].TypeList->begin(),
3534 E = yyvsp[-1].TypeList->end(); I != E; ++I)
37093535 Elements.push_back(*I);
37103536
3711 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
3712 delete (yyvsp[-1].TypeList);
3713 CHECK_FOR_ERROR
3714 ;}
3537 yyval.TypeVal = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
3538 delete yyvsp[-1].TypeList;
3539 CHECK_FOR_ERROR
3540 }
37153541 break;
37163542
37173543 case 134:
3718 #line 1415 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3544 #line 1415 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
37193545 { // Empty structure type?
3720 (yyval.TypeVal) = new PATypeHolder(StructType::get(std::vector()));
3721 CHECK_FOR_ERROR
3722 ;}
3546 yyval.TypeVal = new PATypeHolder(StructType::get(std::vector()));
3547 CHECK_FOR_ERROR
3548 }
37233549 break;
37243550
37253551 case 135:
3726 #line 1419 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3552 #line 1419 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
37273553 {
37283554 std::vector Elements;
3729 for (std::list::iterator I = (yyvsp[-2].TypeList)->begin(),
3730 E = (yyvsp[-2].TypeList)->end(); I != E; ++I)
3555 for (std::list::iterator I = yyvsp[-2].TypeList->begin(),
3556 E = yyvsp[-2].TypeList->end(); I != E; ++I)
37313557 Elements.push_back(*I);
37323558
3733 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
3734 delete (yyvsp[-2].TypeList);
3735 CHECK_FOR_ERROR
3736 ;}
3559 yyval.TypeVal = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
3560 delete yyvsp[-2].TypeList;
3561 CHECK_FOR_ERROR
3562 }
37373563 break;
37383564
37393565 case 136:
3740 #line 1429 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3566 #line 1429 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
37413567 { // Empty structure type?
3742 (yyval.TypeVal) = new PATypeHolder(StructType::get(std::vector(), true));
3743 CHECK_FOR_ERROR
3744 ;}
3568 yyval.TypeVal = new PATypeHolder(StructType::get(std::vector(), true));
3569 CHECK_FOR_ERROR
3570 }
37453571 break;
37463572
37473573 case 137:
3748 #line 1436 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3574 #line 1436 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
37493575 {
3750 (yyval.TypeWithAttrs).Ty = (yyvsp[-1].TypeVal);
3751 (yyval.TypeWithAttrs).Attrs = (yyvsp[0].ParamAttrs);
3752 ;}
3576 yyval.TypeWithAttrs.Ty = yyvsp[-1].TypeVal;
3577 yyval.TypeWithAttrs.Attrs = yyvsp[0].ParamAttrs;
3578 }
37533579 break;
37543580
37553581 case 138:
3756 #line 1443 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3582 #line 1443 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
37573583 {
37583584 if (!UpRefs.empty())
3759 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[0].TypeVal))->getDescription());
3760 if (!(*(yyvsp[0].TypeVal))->isFirstClassType())
3585 GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
3586 if (!(*yyvsp[0].TypeVal)->isFirstClassType())
37613587 GEN_ERROR("LLVM functions cannot return aggregate types");
3762 (yyval.TypeVal) = (yyvsp[0].TypeVal);
3763 ;}
3588 yyval.TypeVal = yyvsp[0].TypeVal;
3589 }
37643590 break;
37653591
37663592 case 139:
3767 #line 1450 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3768 {
3769 (yyval.TypeVal) = new PATypeHolder(Type::VoidTy);
3770 ;}
3593 #line 1450 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3594 {
3595 yyval.TypeVal = new PATypeHolder(Type::VoidTy);
3596 }
37713597 break;
37723598
37733599 case 140:
3774 #line 1455 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3775 {
3776 (yyval.TypeWithAttrsList) = new TypeWithAttrsList();
3777 (yyval.TypeWithAttrsList)->push_back((yyvsp[0].TypeWithAttrs));
3778 CHECK_FOR_ERROR
3779 ;}
3600 #line 1455 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3601 {
3602 yyval.TypeWithAttrsList = new TypeWithAttrsList();
3603 yyval.TypeWithAttrsList->push_back(yyvsp[0].TypeWithAttrs);
3604 CHECK_FOR_ERROR
3605 }
37803606 break;
37813607
37823608 case 141:
3783 #line 1460 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3784 {
3785 ((yyval.TypeWithAttrsList)=(yyvsp[-2].TypeWithAttrsList))->push_back((yyvsp[0].TypeWithAttrs));
3786 CHECK_FOR_ERROR
3787 ;}
3609 #line 1460 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3610 {
3611 (yyval.TypeWithAttrsList=yyvsp[-2].TypeWithAttrsList)->push_back(yyvsp[0].TypeWithAttrs);
3612 CHECK_FOR_ERROR
3613 }
37883614 break;
37893615
37903616 case 143:
3791 #line 1468 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3792 {
3793 (yyval.TypeWithAttrsList)=(yyvsp[-2].TypeWithAttrsList);
3617 #line 1468 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3618 {
3619 yyval.TypeWithAttrsList=yyvsp[-2].TypeWithAttrsList;
37943620 TypeWithAttrs TWA; TWA.Attrs = ParamAttr::None;
37953621 TWA.Ty = new PATypeHolder(Type::VoidTy);
3796 (yyval.TypeWithAttrsList)->push_back(TWA);
3797 CHECK_FOR_ERROR
3798 ;}
3622 yyval.TypeWithAttrsList->push_back(TWA);
3623 CHECK_FOR_ERROR
3624 }
37993625 break;
38003626
38013627 case 144:
3802 #line 1475 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3803 {
3804 (yyval.TypeWithAttrsList) = new TypeWithAttrsList;
3628 #line 1475 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3629 {
3630 yyval.TypeWithAttrsList = new TypeWithAttrsList;
38053631 TypeWithAttrs TWA; TWA.Attrs = ParamAttr::None;
38063632 TWA.Ty = new PATypeHolder(Type::VoidTy);
3807 (yyval.TypeWithAttrsList)->push_back(TWA);
3808 CHECK_FOR_ERROR
3809 ;}
3633 yyval.TypeWithAttrsList->push_back(TWA);
3634 CHECK_FOR_ERROR
3635 }
38103636 break;
38113637
38123638 case 145:
3813 #line 1482 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3814 {
3815 (yyval.TypeWithAttrsList) = new TypeWithAttrsList();
3816 CHECK_FOR_ERROR
3817 ;}
3639 #line 1482 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3640 {
3641 yyval.TypeWithAttrsList = new TypeWithAttrsList();
3642 CHECK_FOR_ERROR
3643 }
38183644 break;
38193645
38203646 case 146:
3821 #line 1490 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3822 {
3823 (yyval.TypeList) = new std::list();
3824 (yyval.TypeList)->push_back(*(yyvsp[0].TypeVal));
3825 delete (yyvsp[0].TypeVal);
3826 CHECK_FOR_ERROR
3827 ;}
3647 #line 1490 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3648 {
3649 yyval.TypeList = new std::list();
3650 yyval.TypeList->push_back(*yyvsp[0].TypeVal);
3651 delete yyvsp[0].TypeVal;
3652 CHECK_FOR_ERROR
3653 }
38283654 break;
38293655
38303656 case 147:
3831 #line 1496 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3832 {
3833 ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back(*(yyvsp[0].TypeVal));
3834 delete (yyvsp[0].TypeVal);
3835 CHECK_FOR_ERROR
3836 ;}
3657 #line 1496 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3658 {
3659 (yyval.TypeList=yyvsp[-2].TypeList)->push_back(*yyvsp[0].TypeVal);
3660 delete yyvsp[0].TypeVal;
3661 CHECK_FOR_ERROR
3662 }
38373663 break;
38383664
38393665 case 148:
3840 #line 1508 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3666 #line 1508 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
38413667 { // Nonempty unsized arr
38423668 if (!UpRefs.empty())
3843 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-3].TypeVal))->getDescription());
3844 const ArrayType *ATy = dyn_cast((yyvsp[-3].TypeVal)->get());
3669 GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
3670 const ArrayType *ATy = dyn_cast(yyvsp[-3].TypeVal->get());
38453671 if (ATy == 0)
38463672 GEN_ERROR("Cannot make array constant with type: '" +
3847 (*(yyvsp[-3].TypeVal))->getDescription() + "'");
3673 (*yyvsp[-3].TypeVal)->getDescription() + "'");
38483674 const Type *ETy = ATy->getElementType();
38493675 int NumElements = ATy->getNumElements();
38503676
38513677 // Verify that we have the correct size...
3852 if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
3678 if (NumElements != -1 && NumElements != (int)yyvsp[-1].ConstVector->size())
38533679 GEN_ERROR("Type mismatch: constant sized array initialized with " +
3854 utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " +
3680 utostr(yyvsp[-1].ConstVector->size()) + " arguments, but has size of " +
38553681 itostr(NumElements) + "");
38563682
38573683 // Verify all elements are correct type!
3858 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
3859 if (ETy != (*(yyvsp[-1].ConstVector))[i]->getType())
3684 for (unsigned i = 0; i < yyvsp[-1].ConstVector->size(); i++) {
3685 if (ETy != (*yyvsp[-1].ConstVector)[i]->getType())
38603686 GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
38613687 ETy->getDescription() +"' as required!\nIt is of type '"+
3862 (*(yyvsp[-1].ConstVector))[i]->getType()->getDescription() + "'.");
3688 (*yyvsp[-1].ConstVector)[i]->getType()->getDescription() + "'.");
38633689 }
38643690
3865 (yyval.ConstVal) = ConstantArray::get(ATy, *(yyvsp[-1].ConstVector));
3866 delete (yyvsp[-3].TypeVal); delete (yyvsp[-1].ConstVector);
3867 CHECK_FOR_ERROR
3868 ;}
3691 yyval.ConstVal = ConstantArray::get(ATy, *yyvsp[-1].ConstVector);
3692 delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector;
3693 CHECK_FOR_ERROR
3694 }
38693695 break;
38703696
38713697 case 149:
3872 #line 1536 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3698 #line 1536 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
38733699 {
38743700 if (!UpRefs.empty())
3875 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
3876 const ArrayType *ATy = dyn_cast((yyvsp[-2].TypeVal)->get());
3701 GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
3702 const ArrayType *ATy = dyn_cast(yyvsp[-2].TypeVal->get());
38773703 if (ATy == 0)
38783704 GEN_ERROR("Cannot make array constant with type: '" +
3879 (*(yyvsp[-2].TypeVal))->getDescription() + "'");
3705 (*yyvsp[-2].TypeVal)->getDescription() + "'");
38803706
38813707 int NumElements = ATy->getNumElements();
38823708 if (NumElements != -1 && NumElements != 0)
38833709 GEN_ERROR("Type mismatch: constant sized array initialized with 0"
38843710 " arguments, but has size of " + itostr(NumElements) +"");
3885 (yyval.ConstVal) = ConstantArray::get(ATy, std::vector());
3886 delete (yyvsp[-2].TypeVal);
3887 CHECK_FOR_ERROR
3888 ;}
3711 yyval.ConstVal = ConstantArray::get(ATy, std::vector());
3712 delete yyvsp[-2].TypeVal;
3713 CHECK_FOR_ERROR
3714 }
38893715 break;
38903716
38913717 case 150:
3892 #line 1552 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3718 #line 1552 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
38933719 {
38943720 if (!UpRefs.empty())
3895 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
3896 const ArrayType *ATy = dyn_cast((yyvsp[-2].TypeVal)->get());
3721 GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
3722 const ArrayType *ATy = dyn_cast(yyvsp[-2].TypeVal->get());
38973723 if (ATy == 0)
38983724 GEN_ERROR("Cannot make array constant with type: '" +
3899 (*(yyvsp[-2].TypeVal))->getDescription() + "'");
3725 (*yyvsp[-2].TypeVal)->getDescription() + "'");
39003726
39013727 int NumElements = ATy->getNumElements();
39023728 const Type *ETy = ATy->getElementType();
3903 char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
3904 if (NumElements != -1 && NumElements != (EndStr-(yyvsp[0].StrVal)))
3729 char *EndStr = UnEscapeLexed(yyvsp[0].StrVal, true);
3730 if (NumElements != -1 && NumElements != (EndStr-yyvsp[0].StrVal))
39053731 GEN_ERROR("Can't build string constant of size " +
3906 itostr((int)(EndStr-(yyvsp[0].StrVal))) +
3732 itostr((int)(EndStr-yyvsp[0].StrVal)) +
39073733 " when array has size " + itostr(NumElements) + "");
39083734 std::vector Vals;
39093735 if (ETy == Type::Int8Ty) {
3910 for (unsigned char *C = (unsigned char *)(yyvsp[0].StrVal);
3736 for (unsigned char *C = (unsigned char *)yyvsp[0].StrVal;
39113737 C != (unsigned char*)EndStr; ++C)
39123738 Vals.push_back(ConstantInt::get(ETy, *C));
39133739 } else {
3914 free((yyvsp[0].StrVal));
3740 free(yyvsp[0].StrVal);
39153741 GEN_ERROR("Cannot build string arrays of non byte sized elements");
39163742 }
3917 free((yyvsp[0].StrVal));
3918 (yyval.ConstVal) = ConstantArray::get(ATy, Vals);
3919 delete (yyvsp[-2].TypeVal);
3920 CHECK_FOR_ERROR
3921 ;}
3743 free(yyvsp[0].StrVal);
3744 yyval.ConstVal = ConstantArray::get(ATy, Vals);
3745 delete yyvsp[-2].TypeVal;
3746 CHECK_FOR_ERROR
3747 }
39223748 break;
39233749
39243750 case 151:
3925 #line 1581 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3751 #line 1581 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
39263752 { // Nonempty unsized arr
39273753 if (!UpRefs.empty())
3928 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-3].TypeVal))->getDescription());
3929 const VectorType *PTy = dyn_cast((yyvsp[-3].TypeVal)->get());
3754 GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
3755 const VectorType *PTy = dyn_cast(yyvsp[-3].TypeVal->get());
39303756 if (PTy == 0)
39313757 GEN_ERROR("Cannot make packed constant with type: '" +
3932 (*(yyvsp[-3].TypeVal))->getDescription() + "'");
3758 (*yyvsp[-3].TypeVal)->getDescription() + "'");
39333759 const Type *ETy = PTy->getElementType();
39343760 int NumElements = PTy->getNumElements();
39353761
39363762 // Verify that we have the correct size...
3937 if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
3763 if (NumElements != -1 && NumElements != (int)yyvsp[-1].ConstVector->size())
39383764 GEN_ERROR("Type mismatch: constant sized packed initialized with " +
3939 utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " +
3765 utostr(yyvsp[-1].ConstVector->size()) + " arguments, but has size of " +
39403766 itostr(NumElements) + "");
39413767
39423768 // Verify all elements are correct type!
3943 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
3944 if (ETy != (*(yyvsp[-1].ConstVector))[i]->getType())
3769 for (unsigned i = 0; i < yyvsp[-1].ConstVector->size(); i++) {
3770 if (ETy != (*yyvsp[-1].ConstVector)[i]->getType())
39453771 GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
39463772 ETy->getDescription() +"' as required!\nIt is of type '"+
3947 (*(yyvsp[-1].ConstVector))[i]->getType()->getDescription() + "'.");
3773 (*yyvsp[-1].ConstVector)[i]->getType()->getDescription() + "'.");
39483774 }
39493775
3950 (yyval.ConstVal) = ConstantVector::get(PTy, *(yyvsp[-1].ConstVector));
3951 delete (yyvsp[-3].TypeVal); delete (yyvsp[-1].ConstVector);
3952 CHECK_FOR_ERROR
3953 ;}
3776 yyval.ConstVal = ConstantVector::get(PTy, *yyvsp[-1].ConstVector);
3777 delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector;
3778 CHECK_FOR_ERROR
3779 }
39543780 break;
39553781
39563782 case 152:
3957 #line 1609 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3958 {
3959 const StructType *STy = dyn_cast((yyvsp[-3].TypeVal)->get());
3783 #line 1609 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3784 {
3785 const StructType *STy = dyn_cast(yyvsp[-3].TypeVal->get());
39603786 if (STy == 0)
39613787 GEN_ERROR("Cannot make struct constant with type: '" +
3962 (*(yyvsp[-3].TypeVal))->getDescription() + "'");
3963
3964 if ((yyvsp[-1].ConstVector)->size() != STy->getNumContainedTypes())
3788 (*yyvsp[-3].TypeVal)->getDescription() + "'");
3789
3790 if (yyvsp[-1].ConstVector->size() != STy->getNumContainedTypes())
39653791 GEN_ERROR("Illegal number of initializers for structure type");
39663792
39673793 // Check to ensure that constants are compatible with the type initializer!
3968 for (unsigned i = 0, e = (yyvsp[-1].ConstVector)->size(); i != e; ++i)
3969 if ((*(yyvsp[-1].ConstVector))[i]->getType() != STy->getElementType(i))
3794 for (unsigned i = 0, e = yyvsp[-1].ConstVector->size(); i != e; ++i)
3795 if ((*yyvsp[-1].ConstVector)[i]->getType() != STy->getElementType(i))
39703796 GEN_ERROR("Expected type '" +
39713797 STy->getElementType(i)->getDescription() +
39723798 "' for element #" + utostr(i) +
39773803 GEN_ERROR("Unpacked Initializer to vector type '" +
39783804 STy->getDescription() + "'");
39793805
3980 (yyval.ConstVal) = ConstantStruct::get(STy, *(yyvsp[-1].ConstVector));
3981 delete (yyvsp[-3].TypeVal); delete (yyvsp[-1].ConstVector);
3982 CHECK_FOR_ERROR
3983 ;}
3806 yyval.ConstVal = ConstantStruct::get(STy, *yyvsp[-1].ConstVector);
3807 delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector;
3808 CHECK_FOR_ERROR
3809 }
39843810 break;
39853811
39863812 case 153:
3987 #line 1635 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3813 #line 1635 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
39883814 {
39893815 if (!UpRefs.empty())
3990 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
3991 const StructType *STy = dyn_cast((yyvsp[-2].TypeVal)->get());
3816 GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
3817 const StructType *STy = dyn_cast(yyvsp[-2].TypeVal->get());
39923818 if (STy == 0)
39933819 GEN_ERROR("Cannot make struct constant with type: '" +
3994 (*(yyvsp[-2].TypeVal))->getDescription() + "'");
3820 (*yyvsp[-2].TypeVal)->getDescription() + "'");
39953821
39963822 if (STy->getNumContainedTypes() != 0)
39973823 GEN_ERROR("Illegal number of initializers for structure type");
40013827 GEN_ERROR("Unpacked Initializer to vector type '" +
40023828 STy->getDescription() + "'");
40033829
4004 (yyval.ConstVal) = ConstantStruct::get(STy, std::vector());
4005 delete (yyvsp[-2].TypeVal);
4006 CHECK_FOR_ERROR
4007 ;}
3830 yyval.ConstVal = ConstantStruct::get(STy, std::vector());
3831 delete yyvsp[-2].TypeVal;
3832 CHECK_FOR_ERROR
3833 }
40083834 break;
40093835
40103836 case 154:
4011 #line 1655 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4012 {
4013 const StructType *STy = dyn_cast((yyvsp[-5].TypeVal)->get());
3837 #line 1655 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
3838 {
3839 const StructType *STy = dyn_cast(yyvsp[-5].TypeVal->get());
40143840 if (STy == 0)
40153841 GEN_ERROR("Cannot make struct constant with type: '" +
4016 (*(yyvsp[-5].TypeVal))->getDescription() + "'");
4017
4018 if ((yyvsp[-2].ConstVector)->size() != STy->getNumContainedTypes())
3842 (*yyvsp[-5].TypeVal)->getDescription() + "'");
3843
3844 if (yyvsp[-2].ConstVector->size() != STy->getNumContainedTypes())
40193845 GEN_ERROR("Illegal number of initializers for structure type");
40203846
40213847 // Check to ensure that constants are compatible with the type initializer!
4022 for (unsigned i = 0, e = (yyvsp[-2].ConstVector)->size(); i != e; ++i)
4023 if ((*(yyvsp[-2].ConstVector))[i]->getType() != STy->getElementType(i))
3848 for (unsigned i = 0, e = yyvsp[-2].ConstVector->size(); i != e; ++i)
3849 if ((*yyvsp[-2].ConstVector)[i]->getType() != STy->getElementType(i))
40243850 GEN_ERROR("Expected type '" +
40253851 STy->getElementType(i)->getDescription() +
40263852 "' for element #" + utostr(i) +
40313857 GEN_ERROR("Vector initializer to non-vector type '" +
40323858 STy->getDescription() + "'");
40333859
4034 (yyval.ConstVal) = ConstantStruct::get(STy, *(yyvsp[-2].ConstVector));
4035 delete (yyvsp[-5].TypeVal); delete (yyvsp[-2].ConstVector);
4036 CHECK_FOR_ERROR
4037 ;}
3860 yyval.ConstVal = ConstantStruct::get(STy, *yyvsp[-2].ConstVector);
3861 delete yyvsp[-5].TypeVal; delete yyvsp[-2].ConstVector;
3862 CHECK_FOR_ERROR
3863 }
40383864 break;
40393865
40403866 case 155:
4041 #line 1681 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3867 #line 1681 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
40423868 {
40433869 if (!UpRefs.empty())
4044 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-4].TypeVal))->getDescription());
4045 const StructType *STy = dyn_cast((yyvsp[-4].TypeVal)->get());
3870 GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription());
3871 const StructType *STy = dyn_cast(yyvsp[-4].TypeVal->get());
40463872 if (STy == 0)
40473873 GEN_ERROR("Cannot make struct constant with type: '" +
4048 (*(yyvsp[-4].TypeVal))->getDescription() + "'");
3874 (*yyvsp[-4].TypeVal)->getDescription() + "'");
40493875
40503876 if (STy->getNumContainedTypes() != 0)
40513877 GEN_ERROR("Illegal number of initializers for structure type");
40553881 GEN_ERROR("Vector initializer to non-vector type '" +
40563882 STy->getDescription() + "'");
40573883
4058 (yyval.ConstVal) = ConstantStruct::get(STy, std::vector());
4059 delete (yyvsp[-4].TypeVal);
4060 CHECK_FOR_ERROR
4061 ;}
3884 yyval.ConstVal = ConstantStruct::get(STy, std::vector());
3885 delete yyvsp[-4].TypeVal;
3886 CHECK_FOR_ERROR
3887 }
40623888 break;
40633889
40643890 case 156:
4065 #line 1701 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3891 #line 1701 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
40663892 {
40673893 if (!UpRefs.empty())
4068 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
4069 const PointerType *PTy = dyn_cast((yyvsp[-1].TypeVal)->get());
3894 GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
3895 const PointerType *PTy = dyn_cast(yyvsp[-1].TypeVal->get());
40703896 if (PTy == 0)
40713897 GEN_ERROR("Cannot make null pointer constant with type: '" +
4072 (*(yyvsp[-1].TypeVal))->getDescription() + "'");
4073
4074 (yyval.ConstVal) = ConstantPointerNull::get(PTy);
4075 delete (yyvsp[-1].TypeVal);
4076 CHECK_FOR_ERROR
4077 ;}
3898 (*yyvsp[-1].TypeVal)->getDescription() + "'");
3899
3900 yyval.ConstVal = ConstantPointerNull::get(PTy);
3901 delete yyvsp[-1].TypeVal;
3902 CHECK_FOR_ERROR
3903 }
40783904 break;
40793905
40803906 case 157:
4081 #line 1713 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3907 #line 1713 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
40823908 {
40833909 if (!UpRefs.empty())
4084 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
4085 (yyval.ConstVal) = UndefValue::get((yyvsp[-1].TypeVal)->get());
4086 delete (yyvsp[-1].TypeVal);
4087 CHECK_FOR_ERROR
4088 ;}
3910 GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
3911 yyval.ConstVal = UndefValue::get(yyvsp[-1].TypeVal->get());
3912 delete yyvsp[-1].TypeVal;
3913 CHECK_FOR_ERROR
3914 }
40893915 break;
40903916
40913917 case 158:
4092 #line 1720 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3918 #line 1720 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
40933919 {
40943920 if (!UpRefs.empty())
4095 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
4096 const PointerType *Ty = dyn_cast((yyvsp[-1].TypeVal)->get());
3921 GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
3922 const PointerType *Ty = dyn_cast(yyvsp[-1].TypeVal->get());
40973923 if (Ty == 0)
40983924 GEN_ERROR("Global const reference must be a pointer type");
40993925
41073933 Function *SavedCurFn = CurFun.CurrentFunction;
41083934 CurFun.CurrentFunction = 0;
41093935
4110 Value *V = getExistingVal(Ty, (yyvsp[0].ValIDVal));
3936 Value *V = getExistingVal(Ty, yyvsp[0].ValIDVal);
41113937 CHECK_FOR_ERROR
41123938
41133939 CurFun.CurrentFunction = SavedCurFn;
41223948
41233949 // First check to see if the forward references value is already created!
41243950 PerModuleInfo::GlobalRefsType::iterator I =
4125 CurModule.GlobalRefs.find(std::make_pair(PT, (yyvsp[0].ValIDVal)));
3951 CurModule.GlobalRefs.find(std::make_pair(PT, yyvsp[0].ValIDVal));
41263952
41273953 if (I != CurModule.GlobalRefs.end()) {
41283954 V = I->second; // Placeholder already exists, use it...
4129 (yyvsp[0].ValIDVal).destroy();
3955 yyvsp[0].ValIDVal.destroy();
41303956 } else {
41313957 std::string Name;
4132 if ((yyvsp[0].ValIDVal).Type == ValID::GlobalName)
4133 Name = (yyvsp[0].ValIDVal).Name;
4134 else if ((yyvsp[0].ValIDVal).Type != ValID::GlobalID)
3958 if (yyvsp[0].ValIDVal.Type == ValID::GlobalName)
3959 Name = yyvsp[0].ValIDVal.Name;
3960 else if (yyvsp[0].ValIDVal.Type != ValID::GlobalID)
41353961 GEN_ERROR("Invalid reference to global");
41363962
41373963 // Create the forward referenced global.
41473973 }
41483974
41493975 // Keep track of the fact that we have a forward ref to recycle it
4150 CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, (yyvsp[0].ValIDVal)), GV));
3976 CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, yyvsp[0].ValIDVal), GV));
41513977 V = GV;
41523978 }
41533979 }
41543980
4155 (yyval.ConstVal) = cast(V);
4156 delete (yyvsp[-1].TypeVal); // Free the type handle
4157 CHECK_FOR_ERROR
4158 ;}
3981 yyval.ConstVal = cast(V);
3982 delete yyvsp[-1].TypeVal; // Free the type handle
3983 CHECK_FOR_ERROR
3984 }
41593985 break;
41603986
41613987 case 159:
4162 #line 1786 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
3988 #line 1786 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
41633989 {
41643990 if (!UpRefs.empty())
4165 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
4166 if ((yyvsp[-1].TypeVal)->get() != (yyvsp[0].ConstVal)->getType())
3991 GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
3992 if (yyvsp[-1].TypeVal->get() != yyvsp[0].ConstVal->getType())
41673993 GEN_ERROR("Mismatched types for constant expression: " +
4168 (*(yyvsp[-1].TypeVal))->getDescription() + " and " + (yyvsp[0].ConstVal)->getType()->getDescription());
4169 (yyval.ConstVal) = (yyvsp[0].ConstVal);
4170 delete (yyvsp[-1].TypeVal);
4171 CHECK_FOR_ERROR
4172 ;}
3994 (*yyvsp[-1].TypeVal)->getDescription() + " and " + yyvsp[0].ConstVal->getType()->getDescription());
3995 yyval.ConstVal = yyvsp[0].ConstVal;
3996 delete yyvsp[-1].TypeVal;
3997 CHECK_FOR_ERROR
3998 }
41733999 break;
41744000
41754001 case 160:
4176 #line 1796 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4002 #line 1796 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
41774003 {
41784004 if (!UpRefs.empty())
4179 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
4180 const Type *Ty = (yyvsp[-1].TypeVal)->get();
4005 GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
4006 const Type *Ty = yyvsp[-1].TypeVal->get();
41814007 if (isa(Ty) || Ty == Type::LabelTy || isa(Ty))
41824008 GEN_ERROR("Cannot create a null initialized value of this type");
4183 (yyval.ConstVal) = Constant::getNullValue(Ty);
4184 delete (yyvsp[-1].TypeVal);
4185 CHECK_FOR_ERROR
4186 ;}
4009 yyval.ConstVal = Constant::getNullValue(Ty);
4010 delete yyvsp[-1].TypeVal;
4011 CHECK_FOR_ERROR
4012 }
41874013 break;
41884014
41894015 case 161:
4190 #line 1806 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4016 #line 1806 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
41914017 { // integral constants
4192 if (!ConstantInt::isValueValidForType((yyvsp[-1].PrimType), (yyvsp[0].SInt64Val)))
4018 if (!ConstantInt::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].SInt64Val))
41934019 GEN_ERROR("Constant value doesn't fit in type");
4194 (yyval.ConstVal) = ConstantInt::get((yyvsp[-1].PrimType), (yyvsp[0].SInt64Val), true);
4195 CHECK_FOR_ERROR
4196 ;}
4020 yyval.ConstVal = ConstantInt::get(yyvsp[-1].PrimType, yyvsp[0].SInt64Val, true);
4021 CHECK_FOR_ERROR
4022 }
41974023 break;
41984024
41994025 case 162:
4200 #line 1812 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4026 #line 1812 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
42014027 { // arbitrary precision integer constants
4202 uint32_t BitWidth = cast((yyvsp[-1].PrimType))->getBitWidth();
4203 if ((yyvsp[0].APIntVal)->getBitWidth() > BitWidth) {
4028 uint32_t BitWidth = cast(yyvsp[-1].PrimType)->getBitWidth();
4029 if (yyvsp[0].APIntVal->getBitWidth() > BitWidth) {
42044030 GEN_ERROR("Constant value does not fit in type");
42054031 }
4206 (yyvsp[0].APIntVal)->sextOrTrunc(BitWidth);
4207 (yyval.ConstVal) = ConstantInt::get(*(yyvsp[0].APIntVal));
4208 delete (yyvsp[0].APIntVal);
4209 CHECK_FOR_ERROR
4210 ;}
4032 yyvsp[0].APIntVal->sextOrTrunc(BitWidth);
4033 yyval.ConstVal = ConstantInt::get(*yyvsp[0].APIntVal);
4034 delete yyvsp[0].APIntVal;
4035 CHECK_FOR_ERROR
4036 }
42114037 break;
42124038
42134039 case 163:
4214 #line 1822 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4040 #line 1822 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
42154041 { // integral constants
4216 if (!ConstantInt::isValueValidForType((yyvsp[-1].PrimType), (yyvsp[0].UInt64Val)))
4042 if (!ConstantInt::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].UInt64Val))
42174043 GEN_ERROR("Constant value doesn't fit in type");
4218 (yyval.ConstVal) = ConstantInt::get((yyvsp[-1].PrimType), (yyvsp[0].UInt64Val), false);
4219 CHECK_FOR_ERROR
4220 ;}
4044 yyval.ConstVal = ConstantInt::get(yyvsp[-1].PrimType, yyvsp[0].UInt64Val, false);
4045 CHECK_FOR_ERROR
4046 }
42214047 break;
42224048
42234049 case 164:
4224 #line 1828 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4050 #line 1828 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
42254051 { // arbitrary precision integer constants
4226 uint32_t BitWidth = cast((yyvsp[-1].PrimType))->getBitWidth();
4227 if ((yyvsp[0].APIntVal)->getBitWidth() > BitWidth) {
4052 uint32_t BitWidth = cast(yyvsp[-1].PrimType)->getBitWidth();
4053 if (yyvsp[0].APIntVal->getBitWidth() > BitWidth) {
42284054 GEN_ERROR("Constant value does not fit in type");
42294055 }
4230 (yyvsp[0].APIntVal)->zextOrTrunc(BitWidth);
4231 (yyval.ConstVal) = ConstantInt::get(*(yyvsp[0].APIntVal));
4232 delete (yyvsp[0].APIntVal);
4233 CHECK_FOR_ERROR
4234 ;}
4056 yyvsp[0].APIntVal->zextOrTrunc(BitWidth);
4057 yyval.ConstVal = ConstantInt::get(*yyvsp[0].APIntVal);
4058 delete yyvsp[0].APIntVal;
4059 CHECK_FOR_ERROR
4060 }
42354061 break;
42364062
42374063 case 165:
4238 #line 1838 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4064 #line 1838 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
42394065 { // Boolean constants
4240 assert(cast((yyvsp[-1].PrimType))->getBitWidth() == 1 && "Not Bool?");
4241 (yyval.ConstVal) = ConstantInt::getTrue();
4242 CHECK_FOR_ERROR
4243 ;}
4066 assert(cast(yyvsp[-1].PrimType)->getBitWidth() == 1 && "Not Bool?");
4067 yyval.ConstVal = ConstantInt::getTrue();
4068 CHECK_FOR_ERROR
4069 }
42444070 break;
42454071
42464072 case 166:
4247 #line 1843 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4073 #line 1843 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
42484074 { // Boolean constants
4249 assert(cast((yyvsp[-1].PrimType))->getBitWidth() == 1 && "Not Bool?");
4250 (yyval.ConstVal) = ConstantInt::getFalse();
4251 CHECK_FOR_ERROR
4252 ;}
4075 assert(cast(yyvsp[-1].PrimType)->getBitWidth() == 1 && "Not Bool?");
4076 yyval.ConstVal = ConstantInt::getFalse();
4077 CHECK_FOR_ERROR
4078 }
42534079 break;
42544080
42554081 case 167:
4256 #line 1848 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4082 #line 1848 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
42574083 { // Float & Double constants
4258 if (!ConstantFP::isValueValidForType((yyvsp[-1].PrimType), (yyvsp[0].FPVal)))
4084 if (!ConstantFP::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].FPVal))
42594085 GEN_ERROR("Floating point constant invalid for type");
4260 (yyval.ConstVal) = ConstantFP::get((yyvsp[-1].PrimType), (yyvsp[0].FPVal));
4261 CHECK_FOR_ERROR
4262 ;}
4086 yyval.ConstVal = ConstantFP::get(yyvsp[-1].PrimType, yyvsp[0].FPVal);
4087 CHECK_FOR_ERROR
4088 }
42634089 break;
42644090
42654091 case 168:
4266 #line 1856 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4092 #line 1856 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
42674093 {
42684094 if (!UpRefs.empty())
4269 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
4270 Constant *Val = (yyvsp[-3].ConstVal);
4271 const Type *DestTy = (yyvsp[-1].TypeVal)->get();
4272 if (!CastInst::castIsValid((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal), DestTy))
4095 GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
4096 Constant *Val = yyvsp[-3].ConstVal;
4097 const Type *DestTy = yyvsp[-1].TypeVal->get();
4098 if (!CastInst::castIsValid(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy))
42734099 GEN_ERROR("invalid cast opcode for cast from '" +
42744100 Val->getType()->getDescription() + "' to '" +
42754101 DestTy->getDescription() + "'");
4276 (yyval.ConstVal) = ConstantExpr::getCast((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal), DestTy);
4277 delete (yyvsp[-1].TypeVal);
4278 ;}
4102 yyval.ConstVal = ConstantExpr::getCast(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy);
4103 delete yyvsp[-1].TypeVal;
4104 }
42794105 break;
42804106
42814107 case 169:
4282 #line 1868 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4283 {
4284 if (!isa((yyvsp[-2].ConstVal)->getType()))
4108 #line 1868 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4109 {
4110 if (!isa(yyvsp[-2].ConstVal->getType()))
42854111 GEN_ERROR("GetElementPtr requires a pointer operand");
42864112
42874113 const Type *IdxTy =
4288 GetElementPtrInst::getIndexedType((yyvsp[-2].ConstVal)->getType(), &(*(yyvsp[-1].ValueList))[0], (yyvsp[-1].ValueList)->size(),
4114 GetElementPtrInst::getIndexedType(yyvsp[-2].ConstVal->getType(), &(*yyvsp[-1].ValueList)[0], yyvsp[-1].ValueList->size(),
42894115 true);
42904116 if (!IdxTy)
42914117 GEN_ERROR("Index list invalid for constant getelementptr");
42924118
42934119 SmallVector IdxVec;
4294 for (unsigned i = 0, e = (yyvsp[-1].ValueList)->size(); i != e; ++i)
4295 if (Constant *C = dyn_cast((*(yyvsp[-1].ValueList))[i]))
4120 for (unsigned i = 0, e = yyvsp[-1].ValueList->size(); i != e; ++i)
4121 if (Constant *C = dyn_cast((*yyvsp[-1].ValueList)[i]))
42964122 IdxVec.push_back(C);
42974123 else
42984124 GEN_ERROR("Indices to constant getelementptr must be constants");
42994125
4300 delete (yyvsp[-1].ValueList);
4301
4302 (yyval.ConstVal) = ConstantExpr::getGetElementPtr((yyvsp[-2].ConstVal), &IdxVec[0], IdxVec.size());
4303 CHECK_FOR_ERROR
4304 ;}
4126 delete yyvsp[-1].ValueList;
4127
4128 yyval.ConstVal = ConstantExpr::getGetElementPtr(yyvsp[-2].ConstVal, &IdxVec[0], IdxVec.size());
4129 CHECK_FOR_ERROR
4130 }
43054131 break;
43064132
43074133 case 170:
4308 #line 1890 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4309 {
4310 if ((yyvsp[-5].ConstVal)->getType() != Type::Int1Ty)
4134 #line 1890 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4135 {
4136 if (yyvsp[-5].ConstVal->getType() != Type::Int1Ty)
43114137 GEN_ERROR("Select condition must be of boolean type");
4312 if ((yyvsp[-3].ConstVal)->getType() != (yyvsp[-1].ConstVal)->getType())
4138 if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
43134139 GEN_ERROR("Select operand types must match");
4314 (yyval.ConstVal) = ConstantExpr::getSelect((yyvsp[-5].ConstVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
4315 CHECK_FOR_ERROR
4316 ;}
4140 yyval.ConstVal = ConstantExpr::getSelect(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
4141 CHECK_FOR_ERROR
4142 }
43174143 break;
43184144
43194145 case 171:
4320 #line 1898 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4321 {
4322 if ((yyvsp[-3].ConstVal)->getType() != (yyvsp[-1].ConstVal)->getType())
4146 #line 1898 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4147 {
4148 if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
43234149 GEN_ERROR("Binary operator types must match");
43244150 CHECK_FOR_ERROR;
4325 (yyval.ConstVal) = ConstantExpr::get((yyvsp[-5].BinaryOpVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
4326 ;}
4151 yyval.ConstVal = ConstantExpr::get(yyvsp[-5].BinaryOpVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
4152 }
43274153 break;
43284154
43294155 case 172:
4330 #line 1904 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4331 {
4332 if ((yyvsp[-3].ConstVal)->getType() != (yyvsp[-1].ConstVal)->getType())
4156 #line 1904 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4157 {
4158 if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
43334159 GEN_ERROR("Logical operator types must match");
4334 if (!(yyvsp[-3].ConstVal)->getType()->isInteger()) {
4335 if (Instruction::isShift((yyvsp[-5].BinaryOpVal)) || !isa((yyvsp[-3].ConstVal)->getType()) ||
4336 !cast((yyvsp[-3].ConstVal)->getType())->getElementType()->isInteger())
4160 if (!yyvsp[-3].ConstVal->getType()->isInteger()) {
4161 if (Instruction::isShift(yyvsp[-5].BinaryOpVal) || !isa(yyvsp[-3].ConstVal->getType()) ||
4162 !cast(yyvsp[-3].ConstVal->getType())->getElementType()->isInteger())
43374163 GEN_ERROR("Logical operator requires integral operands");
43384164 }
4339 (yyval.ConstVal) = ConstantExpr::get((yyvsp[-5].BinaryOpVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
4340 CHECK_FOR_ERROR
4341 ;}
4165 yyval.ConstVal = ConstantExpr::get(yyvsp[-5].BinaryOpVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
4166 CHECK_FOR_ERROR
4167 }
43424168 break;
43434169
43444170 case 173:
4345 #line 1915 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4346 {
4347 if ((yyvsp[-3].ConstVal)->getType() != (yyvsp[-1].ConstVal)->getType())
4171 #line 1915 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4172 {
4173 if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
43484174 GEN_ERROR("icmp operand types must match");
4349 (yyval.ConstVal) = ConstantExpr::getICmp((yyvsp[-5].IPredicate), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
4350 ;}
4175 yyval.ConstVal = ConstantExpr::getICmp(yyvsp[-5].IPredicate, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
4176 }
43514177 break;
43524178
43534179 case 174:
4354 #line 1920 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4355 {
4356 if ((yyvsp[-3].ConstVal)->getType() != (yyvsp[-1].ConstVal)->getType())
4180 #line 1920 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4181 {
4182 if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
43574183 GEN_ERROR("fcmp operand types must match");
4358 (yyval.ConstVal) = ConstantExpr::getFCmp((yyvsp[-5].FPredicate), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
4359 ;}
4184 yyval.ConstVal = ConstantExpr::getFCmp(yyvsp[-5].FPredicate, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
4185 }
43604186 break;
43614187
43624188 case 175:
4363 #line 1925 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4364 {
4365 if (!ExtractElementInst::isValidOperands((yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal)))
4189 #line 1925 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4190 {
4191 if (!ExtractElementInst::isValidOperands(yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
43664192 GEN_ERROR("Invalid extractelement operands");
4367 (yyval.ConstVal) = ConstantExpr::getExtractElement((yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
4368 CHECK_FOR_ERROR
4369 ;}
4193 yyval.ConstVal = ConstantExpr::getExtractElement(yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
4194 CHECK_FOR_ERROR
4195 }
43704196 break;
43714197
43724198 case 176:
4373 #line 1931 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4374 {
4375 if (!InsertElementInst::isValidOperands((yyvsp[-5].ConstVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal)))
4199 #line 1931 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4200 {
4201 if (!InsertElementInst::isValidOperands(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
43764202 GEN_ERROR("Invalid insertelement operands");
4377 (yyval.ConstVal) = ConstantExpr::getInsertElement((yyvsp[-5].ConstVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
4378 CHECK_FOR_ERROR
4379 ;}
4203 yyval.ConstVal = ConstantExpr::getInsertElement(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
4204 CHECK_FOR_ERROR
4205 }
43804206 break;
43814207
43824208 case 177:
4383 #line 1937 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4384 {
4385 if (!ShuffleVectorInst::isValidOperands((yyvsp[-5].ConstVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal)))
4209 #line 1937 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4210 {
4211 if (!ShuffleVectorInst::isValidOperands(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
43864212 GEN_ERROR("Invalid shufflevector operands");
4387 (yyval.ConstVal) = ConstantExpr::getShuffleVector((yyvsp[-5].ConstVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
4388 CHECK_FOR_ERROR
4389 ;}
4213 yyval.ConstVal = ConstantExpr::getShuffleVector(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
4214 CHECK_FOR_ERROR
4215 }
43904216 break;
43914217
43924218 case 178:
4393 #line 1946 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4394 {
4395 ((yyval.ConstVector) = (yyvsp[-2].ConstVector))->push_back((yyvsp[0].ConstVal));
4396 CHECK_FOR_ERROR
4397 ;}
4219 #line 1946 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4220 {
4221 (yyval.ConstVector = yyvsp[-2].ConstVector)->push_back(yyvsp[0].ConstVal);
4222 CHECK_FOR_ERROR
4223 }
43984224 break;
43994225
44004226 case 179:
4401 #line 1950 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4402 {
4403 (yyval.ConstVector) = new std::vector();
4404 (yyval.ConstVector)->push_back((yyvsp[0].ConstVal));
4405 CHECK_FOR_ERROR
4406 ;}
4227 #line 1950 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4228 {
4229 yyval.ConstVector = new std::vector();
4230 yyval.ConstVector->push_back(yyvsp[0].ConstVal);
4231 CHECK_FOR_ERROR
4232 }
44074233 break;
44084234
44094235 case 180:
4410 #line 1958 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4411 { (yyval.BoolVal) = false; ;}
4236 #line 1958 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4237 { yyval.BoolVal = false; }
44124238 break;
44134239
44144240 case 181:
4415 #line 1958 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4416 { (yyval.BoolVal) = true; ;}
4241 #line 1958 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4242 { yyval.BoolVal = true; }
44174243 break;
44184244
44194245 case 182:
4420 #line 1961 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4421 { (yyval.BoolVal) = true; ;}
4246 #line 1961 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4247 { yyval.BoolVal = true; }
44224248 break;
44234249
44244250 case 183:
4425 #line 1961 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4426 { (yyval.BoolVal) = false; ;}
4251 #line 1961 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4252 { yyval.BoolVal = false; }
44274253 break;
44284254
44294255 case 184:
4430 #line 1964 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4431 {
4432 const Type* VTy = (yyvsp[-1].TypeVal)->get();
4433 Value *V = getVal(VTy, (yyvsp[0].ValIDVal));
4256 #line 1964 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4257 {
4258 const Type* VTy = yyvsp[-1].TypeVal->get();
4259 Value *V = getVal(VTy, yyvsp[0].ValIDVal);
44344260 GlobalValue* Aliasee = dyn_cast(V);
44354261 if (!Aliasee)
44364262 GEN_ERROR("Aliases can be created only to global values");
44374263
4438 (yyval.ConstVal) = Aliasee;
4439 CHECK_FOR_ERROR
4440 delete (yyvsp[-1].TypeVal);
4441 ;}
4264 yyval.ConstVal = Aliasee;
4265 CHECK_FOR_ERROR
4266 delete yyvsp[-1].TypeVal;
4267 }
44424268 break;
44434269
44444270 case 185:
4445 #line 1975 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4446 {
4447 Constant *Val = (yyvsp[-3].ConstVal);
4448 const Type *DestTy = (yyvsp[-1].TypeVal)->get();
4449 if (!CastInst::castIsValid((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal), DestTy))
4271 #line 1975 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4272 {
4273 Constant *Val = yyvsp[-3].ConstVal;
4274 const Type *DestTy = yyvsp[-1].TypeVal->get();
4275 if (!CastInst::castIsValid(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy))
44504276 GEN_ERROR("invalid cast opcode for cast from '" +
44514277 Val->getType()->getDescription() + "' to '" +
44524278 DestTy->getDescription() + "'");
44534279
4454 (yyval.ConstVal) = ConstantExpr::getCast((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal), DestTy);
4455 CHECK_FOR_ERROR
4456 delete (yyvsp[-1].TypeVal);
4457 ;}
4280 yyval.ConstVal = ConstantExpr::getCast(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy);
4281 CHECK_FOR_ERROR
4282 delete yyvsp[-1].TypeVal;
4283 }
44584284 break;
44594285
44604286 case 186:
4461 #line 1996 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4462 {
4463 (yyval.ModuleVal) = ParserResult = CurModule.CurrentModule;
4287 #line 1996 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4288 {
4289 yyval.ModuleVal = ParserResult = CurModule.CurrentModule;
44644290 CurModule.ModuleDone();
44654291 CHECK_FOR_ERROR;
4466 ;}
4292 }
44674293 break;
44684294
44694295 case 187:
4470 #line 2001 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4471 {
4472 (yyval.ModuleVal) = ParserResult = CurModule.CurrentModule;
4296 #line 2001 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4297 {
4298 yyval.ModuleVal = ParserResult = CurModule.CurrentModule;
44734299 CurModule.ModuleDone();
44744300 CHECK_FOR_ERROR;
4475 ;}
4301 }
44764302 break;
44774303
44784304 case 190:
4479 #line 2014 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4480 { CurFun.isDeclare = false; ;}
4305 #line 2014 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4306 { CurFun.isDeclare = false; }
44814307 break;
44824308
44834309 case 191:
4484 #line 2014 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4310 #line 2014 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
44854311 {
44864312 CurFun.FunctionDone();
44874313 CHECK_FOR_ERROR
4488 ;}
4314 }
44894315 break;
44904316
44914317 case 192:
4492 #line 2018 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4493 { CurFun.isDeclare = true; ;}
4318 #line 2018 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4319 { CurFun.isDeclare = true; }
44944320 break;
44954321
44964322 case 193:
4497 #line 2018 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4498 {
4499 CHECK_FOR_ERROR
4500 ;}
4323 #line 2018 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4324 {
4325 CHECK_FOR_ERROR
4326 }
45014327 break;
45024328
45034329 case 194:
4504 #line 2021 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4505 {
4506 CHECK_FOR_ERROR
4507 ;}
4330 #line 2021 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4331 {
4332 CHECK_FOR_ERROR
4333 }
45084334 break;
45094335
45104336 case 195:
4511 #line 2024 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4337 #line 2024 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
45124338 {
45134339 if (!UpRefs.empty())
4514 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[0].TypeVal))->getDescription());
4340 GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
45154341 // Eagerly resolve types. This is not an optimization, this is a
45164342 // requirement that is due to the fact that we could have this:
45174343 //
45214347 // If types are not resolved eagerly, then the two types will not be
45224348 // determined to be the same type!
45234349 //
4524 ResolveTypeTo((yyvsp[-2].StrVal), *(yyvsp[0].TypeVal));
4525
4526 if (!setTypeName(*(yyvsp[0].TypeVal), (yyvsp[-2].StrVal)) && !(yyvsp[-2].StrVal)) {
4350 ResolveTypeTo(yyvsp[-2].StrVal, *yyvsp[0].TypeVal);
4351
4352 if (!setTypeName(*yyvsp[0].TypeVal, yyvsp[-2].StrVal) && !yyvsp[-2].StrVal) {
45274353 CHECK_FOR_ERROR
45284354 // If this is a named type that is not a redefinition, add it to the slot
45294355 // table.
4530 CurModule.Types.push_back(*(yyvsp[0].TypeVal));
4356 CurModule.Types.push_back(*yyvsp[0].TypeVal);
45314357 }
45324358
4533 delete (yyvsp[0].TypeVal);
4534 CHECK_FOR_ERROR
4535 ;}
4359 delete yyvsp[0].TypeVal;
4360 CHECK_FOR_ERROR
4361 }
45364362 break;
45374363
45384364 case 196:
4539 #line 2048 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4540 {
4541 ResolveTypeTo((yyvsp[-2].StrVal), (yyvsp[0].PrimType));
4542
4543 if (!setTypeName((yyvsp[0].PrimType), (yyvsp[-2].StrVal)) && !(yyvsp[-2].StrVal)) {
4365 #line 2048 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4366 {
4367 ResolveTypeTo(yyvsp[-2].StrVal, yyvsp[0].PrimType);
4368
4369 if (!setTypeName(yyvsp[0].PrimType, yyvsp[-2].StrVal) && !yyvsp[-2].StrVal) {
45444370 CHECK_FOR_ERROR
45454371 // If this is a named type that is not a redefinition, add it to the slot
45464372 // table.
4547 CurModule.Types.push_back((yyvsp[0].PrimType));
4373 CurModule.Types.push_back(yyvsp[0].PrimType);
45484374 }
45494375 CHECK_FOR_ERROR
4550 ;}
4376 }
45514377 break;
45524378
45534379 case 197:
4554 #line 2059 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4380 #line 2059 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
45554381 {
45564382 /* "Externally Visible" Linkage */
4557 if ((yyvsp[0].ConstVal) == 0)
4383 if (yyvsp[0].ConstVal == 0)
45584384 GEN_ERROR("Global value initializer is not a constant");
4559 CurGV = ParseGlobalVariable((yyvsp[-4].StrVal), GlobalValue::ExternalLinkage,
4560 (yyvsp[-3].Visibility), (yyvsp[-1].BoolVal), (yyvsp[0].ConstVal)->getType(), (yyvsp[0].ConstVal), (yyvsp[-2].BoolVal));
4561 CHECK_FOR_ERROR
4562 ;}
4385 CurGV = ParseGlobalVariable(yyvsp[-4].StrVal, GlobalValue::ExternalLinkage,
4386 yyvsp[-3].Visibility, yyvsp[-1].BoolVal, yyvsp[0].ConstVal->getType(), yyvsp[0].ConstVal, yyvsp[-2].BoolVal);
4387 CHECK_FOR_ERROR
4388 }
45634389 break;
45644390
45654391 case 198:
4566 #line 2066 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4392 #line 2066 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
45674393 {
45684394 CurGV = 0;
4569 ;}
4395 }
45704396 break;
45714397
45724398 case 199:
4573 #line 2070 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4574 {
4575 if ((yyvsp[0].ConstVal) == 0)
4399 #line 2070 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
4400 {
4401 if (yyvsp[0].ConstVal == 0)
45764402 GEN_ERROR("Global value initializer is not a constant");
4577 CurGV = ParseGlobalVariable((yyvsp[-5].StrVal), (yyvsp[-4].Linkage), (yyvsp[-3].Visibility), (yyvsp[-1].BoolVal), (yyvsp[0].ConstVal)->getType(), (yyvsp[0].ConstVal), (yyvsp[-2].BoolVal));
4578 CHECK_FOR_ERROR
4579 ;}
4403 CurGV = ParseGlobalVariable(yyvsp[-5].StrVal, yyvsp[-4].Linkage, yyvsp[-3].Visibility, yyvsp[-1].BoolVal, yyvsp[0].ConstVal->getType(), yyvsp[0].ConstVal, yyvsp[-2].BoolVal);
4404 CHECK_FOR_ERROR
4405 }
45804406 break;
45814407
45824408 case 200:
4583 #line 2075 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4409 #line 2075 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
45844410 {
45854411 CurGV = 0;
4586 ;}
4412 }
45874413 break;
45884414
45894415 case 201:
4590 #line 2079 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
4416 #line 2079 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
45914417 {
45924418</