aboutsummaryrefslogtreecommitdiffstats
path: root/tools/perf/util/pmu-bison.c
diff options
context:
space:
mode:
Diffstat (limited to 'tools/perf/util/pmu-bison.c')
-rw-r--r--tools/perf/util/pmu-bison.c1663
1 files changed, 0 insertions, 1663 deletions
diff --git a/tools/perf/util/pmu-bison.c b/tools/perf/util/pmu-bison.c
deleted file mode 100644
index 343521ec589f..000000000000
--- a/tools/perf/util/pmu-bison.c
+++ /dev/null
@@ -1,1663 +0,0 @@
1/* A Bison parser, made by GNU Bison 2.4.3. */
2
3/* Skeleton implementation for Bison's Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
6 2009, 2010 Free Software Foundation, Inc.
7
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21/* As a special exception, you may create a larger work that contains
22 part or all of the Bison parser skeleton and distribute that work
23 under terms of your choice, so long as that work isn't itself a
24 parser generator using the skeleton or a modified version thereof
25 as a parser skeleton. Alternatively, if you modify or redistribute
26 the parser skeleton itself, you may (at your option) remove this
27 special exception, which will cause the skeleton and the resulting
28 Bison output files to be licensed under the GNU General Public
29 License without this special exception.
30
31 This special exception was added by the Free Software Foundation in
32 version 2.2 of Bison. */
33
34/* C LALR(1) parser skeleton written by Richard Stallman, by
35 simplifying the original so-called "semantic" parser. */
36
37/* All symbols defined below should begin with yy or YY, to avoid
38 infringing on user name space. This should be done even for local
39 variables, as they might otherwise be expanded by user macros.
40 There are some unavoidable exceptions within include files to
41 define necessary library symbols; they are noted "INFRINGES ON
42 USER NAME SPACE" below. */
43
44/* Identify Bison output. */
45#define YYBISON 1
46
47/* Bison version. */
48#define YYBISON_VERSION "2.4.3"
49
50/* Skeleton name. */
51#define YYSKELETON_NAME "yacc.c"
52
53/* Pure parsers. */
54#define YYPURE 0
55
56/* Push parsers. */
57#define YYPUSH 0
58
59/* Pull parsers. */
60#define YYPULL 1
61
62/* Using locations. */
63#define YYLSP_NEEDED 0
64
65/* Substitute the variable and function names. */
66#define yyparse perf_pmu_parse
67#define yylex perf_pmu_lex
68#define yyerror perf_pmu_error
69#define yylval perf_pmu_lval
70#define yychar perf_pmu_char
71#define yydebug perf_pmu_debug
72#define yynerrs perf_pmu_nerrs
73
74
75/* Copy the first part of user declarations. */
76
77/* Line 189 of yacc.c */
78#line 6 "util/pmu.y"
79
80
81#include <linux/compiler.h>
82#include <linux/list.h>
83#include <linux/bitmap.h>
84#include <string.h>
85#include "pmu.h"
86
87extern int perf_pmu_lex (void);
88
89#define ABORT_ON(val) \
90do { \
91 if (val) \
92 YYABORT; \
93} while (0)
94
95
96
97/* Line 189 of yacc.c */
98#line 99 "util/pmu-bison.c"
99
100/* Enabling traces. */
101#ifndef YYDEBUG
102# define YYDEBUG 0
103#endif
104
105/* Enabling verbose error messages. */
106#ifdef YYERROR_VERBOSE
107# undef YYERROR_VERBOSE
108# define YYERROR_VERBOSE 1
109#else
110# define YYERROR_VERBOSE 0
111#endif
112
113/* Enabling the token table. */
114#ifndef YYTOKEN_TABLE
115# define YYTOKEN_TABLE 0
116#endif
117
118
119/* Tokens. */
120#ifndef YYTOKENTYPE
121# define YYTOKENTYPE
122 /* Put the tokens into the symbol table, so that GDB and other debuggers
123 know about them. */
124 enum yytokentype {
125 PP_CONFIG = 258,
126 PP_CONFIG1 = 259,
127 PP_CONFIG2 = 260,
128 PP_VALUE = 261,
129 PP_ERROR = 262
130 };
131#endif
132
133
134
135#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
136typedef union YYSTYPE
137{
138
139/* Line 214 of yacc.c */
140#line 31 "util/pmu.y"
141
142 unsigned long num;
143 DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS);
144
145
146
147/* Line 214 of yacc.c */
148#line 149 "util/pmu-bison.c"
149} YYSTYPE;
150# define YYSTYPE_IS_TRIVIAL 1
151# define yystype YYSTYPE /* obsolescent; will be withdrawn */
152# define YYSTYPE_IS_DECLARED 1
153#endif
154
155
156/* Copy the second part of user declarations. */
157
158
159/* Line 264 of yacc.c */
160#line 161 "util/pmu-bison.c"
161
162#ifdef short
163# undef short
164#endif
165
166#ifdef YYTYPE_UINT8
167typedef YYTYPE_UINT8 yytype_uint8;
168#else
169typedef unsigned char yytype_uint8;
170#endif
171
172#ifdef YYTYPE_INT8
173typedef YYTYPE_INT8 yytype_int8;
174#elif (defined __STDC__ || defined __C99__FUNC__ \
175 || defined __cplusplus || defined _MSC_VER)
176typedef signed char yytype_int8;
177#else
178typedef short int yytype_int8;
179#endif
180
181#ifdef YYTYPE_UINT16
182typedef YYTYPE_UINT16 yytype_uint16;
183#else
184typedef unsigned short int yytype_uint16;
185#endif
186
187#ifdef YYTYPE_INT16
188typedef YYTYPE_INT16 yytype_int16;
189#else
190typedef short int yytype_int16;
191#endif
192
193#ifndef YYSIZE_T
194# ifdef __SIZE_TYPE__
195# define YYSIZE_T __SIZE_TYPE__
196# elif defined size_t
197# define YYSIZE_T size_t
198# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
199 || defined __cplusplus || defined _MSC_VER)
200# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
201# define YYSIZE_T size_t
202# else
203# define YYSIZE_T unsigned int
204# endif
205#endif
206
207#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
208
209#ifndef YY_
210# if defined YYENABLE_NLS && YYENABLE_NLS
211# if ENABLE_NLS
212# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
213# define YY_(msgid) dgettext ("bison-runtime", msgid)
214# endif
215# endif
216# ifndef YY_
217# define YY_(msgid) msgid
218# endif
219#endif
220
221/* Suppress unused-variable warnings by "using" E. */
222#if ! defined lint || defined __GNUC__
223# define YYUSE(e) ((void) (e))
224#else
225# define YYUSE(e) /* empty */
226#endif
227
228/* Identity function, used to suppress warnings about constant conditions. */
229#ifndef lint
230# define YYID(n) (n)
231#else
232#if (defined __STDC__ || defined __C99__FUNC__ \
233 || defined __cplusplus || defined _MSC_VER)
234static int
235YYID (int yyi)
236#else
237static int
238YYID (yyi)
239 int yyi;
240#endif
241{
242 return yyi;
243}
244#endif
245
246#if ! defined yyoverflow || YYERROR_VERBOSE
247
248/* The parser invokes alloca or malloc; define the necessary symbols. */
249
250# ifdef YYSTACK_USE_ALLOCA
251# if YYSTACK_USE_ALLOCA
252# ifdef __GNUC__
253# define YYSTACK_ALLOC __builtin_alloca
254# elif defined __BUILTIN_VA_ARG_INCR
255# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
256# elif defined _AIX
257# define YYSTACK_ALLOC __alloca
258# elif defined _MSC_VER
259# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
260# define alloca _alloca
261# else
262# define YYSTACK_ALLOC alloca
263# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
264 || defined __cplusplus || defined _MSC_VER)
265# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
266# ifndef _STDLIB_H
267# define _STDLIB_H 1
268# endif
269# endif
270# endif
271# endif
272# endif
273
274# ifdef YYSTACK_ALLOC
275 /* Pacify GCC's `empty if-body' warning. */
276# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
277# ifndef YYSTACK_ALLOC_MAXIMUM
278 /* The OS might guarantee only one guard page at the bottom of the stack,
279 and a page size can be as small as 4096 bytes. So we cannot safely
280 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
281 to allow for a few compiler-allocated temporary stack slots. */
282# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
283# endif
284# else
285# define YYSTACK_ALLOC YYMALLOC
286# define YYSTACK_FREE YYFREE
287# ifndef YYSTACK_ALLOC_MAXIMUM
288# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
289# endif
290# if (defined __cplusplus && ! defined _STDLIB_H \
291 && ! ((defined YYMALLOC || defined malloc) \
292 && (defined YYFREE || defined free)))
293# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
294# ifndef _STDLIB_H
295# define _STDLIB_H 1
296# endif
297# endif
298# ifndef YYMALLOC
299# define YYMALLOC malloc
300# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
301 || defined __cplusplus || defined _MSC_VER)
302void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
303# endif
304# endif
305# ifndef YYFREE
306# define YYFREE free
307# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
308 || defined __cplusplus || defined _MSC_VER)
309void free (void *); /* INFRINGES ON USER NAME SPACE */
310# endif
311# endif
312# endif
313#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
314
315
316#if (! defined yyoverflow \
317 && (! defined __cplusplus \
318 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
319
320/* A type that is properly aligned for any stack member. */
321union yyalloc
322{
323 yytype_int16 yyss_alloc;
324 YYSTYPE yyvs_alloc;
325};
326
327/* The size of the maximum gap between one aligned stack and the next. */
328# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
329
330/* The size of an array large to enough to hold all stacks, each with
331 N elements. */
332# define YYSTACK_BYTES(N) \
333 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
334 + YYSTACK_GAP_MAXIMUM)
335
336/* Copy COUNT objects from FROM to TO. The source and destination do
337 not overlap. */
338# ifndef YYCOPY
339# if defined __GNUC__ && 1 < __GNUC__
340# define YYCOPY(To, From, Count) \
341 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
342# else
343# define YYCOPY(To, From, Count) \
344 do \
345 { \
346 YYSIZE_T yyi; \
347 for (yyi = 0; yyi < (Count); yyi++) \
348 (To)[yyi] = (From)[yyi]; \
349 } \
350 while (YYID (0))
351# endif
352# endif
353
354/* Relocate STACK from its old location to the new one. The
355 local variables YYSIZE and YYSTACKSIZE give the old and new number of
356 elements in the stack, and YYPTR gives the new location of the
357 stack. Advance YYPTR to a properly aligned location for the next
358 stack. */
359# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
360 do \
361 { \
362 YYSIZE_T yynewbytes; \
363 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
364 Stack = &yyptr->Stack_alloc; \
365 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
366 yyptr += yynewbytes / sizeof (*yyptr); \
367 } \
368 while (YYID (0))
369
370#endif
371
372/* YYFINAL -- State number of the termination state. */
373#define YYFINAL 9
374/* YYLAST -- Last index in YYTABLE. */
375#define YYLAST 17
376
377/* YYNTOKENS -- Number of terminals. */
378#define YYNTOKENS 11
379/* YYNNTS -- Number of nonterminals. */
380#define YYNNTS 5
381/* YYNRULES -- Number of rules. */
382#define YYNRULES 10
383/* YYNRULES -- Number of states. */
384#define YYNSTATES 20
385
386/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
387#define YYUNDEFTOK 2
388#define YYMAXUTOK 262
389
390#define YYTRANSLATE(YYX) \
391 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
392
393/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
394static const yytype_uint8 yytranslate[] =
395{
396 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
397 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
398 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
399 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
400 2, 2, 2, 2, 9, 10, 2, 2, 2, 2,
401 2, 2, 2, 2, 2, 2, 2, 2, 8, 2,
402 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
403 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
404 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
405 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
406 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
407 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
408 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
409 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
410 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
411 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
412 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
413 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
414 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
415 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
416 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
417 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
418 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
419 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
420 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
421 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
422 5, 6, 7
423};
424
425#if YYDEBUG
426/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
427 YYRHS. */
428static const yytype_uint8 yyprhs[] =
429{
430 0, 0, 3, 6, 8, 12, 16, 20, 24, 26,
431 30
432};
433
434/* YYRHS -- A `-1'-separated list of the rules' RHS. */
435static const yytype_int8 yyrhs[] =
436{
437 12, 0, -1, 12, 13, -1, 13, -1, 3, 8,
438 14, -1, 4, 8, 14, -1, 5, 8, 14, -1,
439 14, 9, 15, -1, 15, -1, 6, 10, 6, -1,
440 6, -1
441};
442
443/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
444static const yytype_uint8 yyrline[] =
445{
446 0, 39, 39, 41, 44, 51, 58, 66, 71, 77,
447 82
448};
449#endif
450
451#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
452/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
453 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
454static const char *const yytname[] =
455{
456 "$end", "error", "$undefined", "PP_CONFIG", "PP_CONFIG1", "PP_CONFIG2",
457 "PP_VALUE", "PP_ERROR", "':'", "','", "'-'", "$accept", "format",
458 "format_term", "bits", "bit_term", 0
459};
460#endif
461
462# ifdef YYPRINT
463/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
464 token YYLEX-NUM. */
465static const yytype_uint16 yytoknum[] =
466{
467 0, 256, 257, 258, 259, 260, 261, 262, 58, 44,
468 45
469};
470# endif
471
472/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
473static const yytype_uint8 yyr1[] =
474{
475 0, 11, 12, 12, 13, 13, 13, 14, 14, 15,
476 15
477};
478
479/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
480static const yytype_uint8 yyr2[] =
481{
482 0, 2, 2, 1, 3, 3, 3, 3, 1, 3,
483 1
484};
485
486/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
487 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
488 means the default is an error. */
489static const yytype_uint8 yydefact[] =
490{
491 0, 0, 0, 0, 0, 3, 0, 0, 0, 1,
492 2, 10, 4, 8, 5, 6, 0, 0, 9, 7
493};
494
495/* YYDEFGOTO[NTERM-NUM]. */
496static const yytype_int8 yydefgoto[] =
497{
498 -1, 4, 5, 12, 13
499};
500
501/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
502 STATE-NUM. */
503#define YYPACT_NINF -7
504static const yytype_int8 yypact[] =
505{
506 3, 1, 2, 4, 0, -7, 5, 5, 5, -7,
507 -7, 6, 8, -7, 8, 8, 7, 5, -7, -7
508};
509
510/* YYPGOTO[NTERM-NUM]. */
511static const yytype_int8 yypgoto[] =
512{
513 -7, -7, 10, -6, -2
514};
515
516/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
517 positive, shift that token. If negative, reduce the rule which
518 number is the opposite. If zero, do what YYDEFACT says.
519 If YYTABLE_NINF, syntax error. */
520#define YYTABLE_NINF -1
521static const yytype_uint8 yytable[] =
522{
523 9, 14, 15, 1, 2, 3, 1, 2, 3, 6,
524 7, 11, 8, 18, 10, 19, 16, 17
525};
526
527static const yytype_uint8 yycheck[] =
528{
529 0, 7, 8, 3, 4, 5, 3, 4, 5, 8,
530 8, 6, 8, 6, 4, 17, 10, 9
531};
532
533/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
534 symbol of state STATE-NUM. */
535static const yytype_uint8 yystos[] =
536{
537 0, 3, 4, 5, 12, 13, 8, 8, 8, 0,
538 13, 6, 14, 15, 14, 14, 10, 9, 6, 15
539};
540
541#define yyerrok (yyerrstatus = 0)
542#define yyclearin (yychar = YYEMPTY)
543#define YYEMPTY (-2)
544#define YYEOF 0
545
546#define YYACCEPT goto yyacceptlab
547#define YYABORT goto yyabortlab
548#define YYERROR goto yyerrorlab
549
550
551/* Like YYERROR except do call yyerror. This remains here temporarily
552 to ease the transition to the new meaning of YYERROR, for GCC.
553 Once GCC version 2 has supplanted version 1, this can go. However,
554 YYFAIL appears to be in use. Nevertheless, it is formally deprecated
555 in Bison 2.4.2's NEWS entry, where a plan to phase it out is
556 discussed. */
557
558#define YYFAIL goto yyerrlab
559#if defined YYFAIL
560 /* This is here to suppress warnings from the GCC cpp's
561 -Wunused-macros. Normally we don't worry about that warning, but
562 some users do, and we want to make it easy for users to remove
563 YYFAIL uses, which will produce warnings from Bison 2.5. */
564#endif
565
566#define YYRECOVERING() (!!yyerrstatus)
567
568#define YYBACKUP(Token, Value) \
569do \
570 if (yychar == YYEMPTY && yylen == 1) \
571 { \
572 yychar = (Token); \
573 yylval = (Value); \
574 yytoken = YYTRANSLATE (yychar); \
575 YYPOPSTACK (1); \
576 goto yybackup; \
577 } \
578 else \
579 { \
580 yyerror (format, name, YY_("syntax error: cannot back up")); \
581 YYERROR; \
582 } \
583while (YYID (0))
584
585
586#define YYTERROR 1
587#define YYERRCODE 256
588
589
590/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
591 If N is 0, then set CURRENT to the empty location which ends
592 the previous symbol: RHS[0] (always defined). */
593
594#define YYRHSLOC(Rhs, K) ((Rhs)[K])
595#ifndef YYLLOC_DEFAULT
596# define YYLLOC_DEFAULT(Current, Rhs, N) \
597 do \
598 if (YYID (N)) \
599 { \
600 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
601 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
602 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
603 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
604 } \
605 else \
606 { \
607 (Current).first_line = (Current).last_line = \
608 YYRHSLOC (Rhs, 0).last_line; \
609 (Current).first_column = (Current).last_column = \
610 YYRHSLOC (Rhs, 0).last_column; \
611 } \
612 while (YYID (0))
613#endif
614
615
616/* YY_LOCATION_PRINT -- Print the location on the stream.
617 This macro was not mandated originally: define only if we know
618 we won't break user code: when these are the locations we know. */
619
620#ifndef YY_LOCATION_PRINT
621# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
622# define YY_LOCATION_PRINT(File, Loc) \
623 fprintf (File, "%d.%d-%d.%d", \
624 (Loc).first_line, (Loc).first_column, \
625 (Loc).last_line, (Loc).last_column)
626# else
627# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
628# endif
629#endif
630
631
632/* YYLEX -- calling `yylex' with the right arguments. */
633
634#ifdef YYLEX_PARAM
635# define YYLEX yylex (YYLEX_PARAM)
636#else
637# define YYLEX yylex ()
638#endif
639
640/* Enable debugging if requested. */
641#if YYDEBUG
642
643# ifndef YYFPRINTF
644# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
645# define YYFPRINTF fprintf
646# endif
647
648# define YYDPRINTF(Args) \
649do { \
650 if (yydebug) \
651 YYFPRINTF Args; \
652} while (YYID (0))
653
654# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
655do { \
656 if (yydebug) \
657 { \
658 YYFPRINTF (stderr, "%s ", Title); \
659 yy_symbol_print (stderr, \
660 Type, Value, format, name); \
661 YYFPRINTF (stderr, "\n"); \
662 } \
663} while (YYID (0))
664
665
666/*--------------------------------.
667| Print this symbol on YYOUTPUT. |
668`--------------------------------*/
669
670/*ARGSUSED*/
671#if (defined __STDC__ || defined __C99__FUNC__ \
672 || defined __cplusplus || defined _MSC_VER)
673static void
674yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct list_head *format, char *name)
675#else
676static void
677yy_symbol_value_print (yyoutput, yytype, yyvaluep, format, name)
678 FILE *yyoutput;
679 int yytype;
680 YYSTYPE const * const yyvaluep;
681 struct list_head *format;
682 char *name;
683#endif
684{
685 if (!yyvaluep)
686 return;
687 YYUSE (format);
688 YYUSE (name);
689# ifdef YYPRINT
690 if (yytype < YYNTOKENS)
691 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
692# else
693 YYUSE (yyoutput);
694# endif
695 switch (yytype)
696 {
697 default:
698 break;
699 }
700}
701
702
703/*--------------------------------.
704| Print this symbol on YYOUTPUT. |
705`--------------------------------*/
706
707#if (defined __STDC__ || defined __C99__FUNC__ \
708 || defined __cplusplus || defined _MSC_VER)
709static void
710yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct list_head *format, char *name)
711#else
712static void
713yy_symbol_print (yyoutput, yytype, yyvaluep, format, name)
714 FILE *yyoutput;
715 int yytype;
716 YYSTYPE const * const yyvaluep;
717 struct list_head *format;
718 char *name;
719#endif
720{
721 if (yytype < YYNTOKENS)
722 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
723 else
724 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
725
726 yy_symbol_value_print (yyoutput, yytype, yyvaluep, format, name);
727 YYFPRINTF (yyoutput, ")");
728}
729
730/*------------------------------------------------------------------.
731| yy_stack_print -- Print the state stack from its BOTTOM up to its |
732| TOP (included). |
733`------------------------------------------------------------------*/
734
735#if (defined __STDC__ || defined __C99__FUNC__ \
736 || defined __cplusplus || defined _MSC_VER)
737static void
738yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
739#else
740static void
741yy_stack_print (yybottom, yytop)
742 yytype_int16 *yybottom;
743 yytype_int16 *yytop;
744#endif
745{
746 YYFPRINTF (stderr, "Stack now");
747 for (; yybottom <= yytop; yybottom++)
748 {
749 int yybot = *yybottom;
750 YYFPRINTF (stderr, " %d", yybot);
751 }
752 YYFPRINTF (stderr, "\n");
753}
754
755# define YY_STACK_PRINT(Bottom, Top) \
756do { \
757 if (yydebug) \
758 yy_stack_print ((Bottom), (Top)); \
759} while (YYID (0))
760
761
762/*------------------------------------------------.
763| Report that the YYRULE is going to be reduced. |
764`------------------------------------------------*/
765
766#if (defined __STDC__ || defined __C99__FUNC__ \
767 || defined __cplusplus || defined _MSC_VER)
768static void
769yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct list_head *format, char *name)
770#else
771static void
772yy_reduce_print (yyvsp, yyrule, format, name)
773 YYSTYPE *yyvsp;
774 int yyrule;
775 struct list_head *format;
776 char *name;
777#endif
778{
779 int yynrhs = yyr2[yyrule];
780 int yyi;
781 unsigned long int yylno = yyrline[yyrule];
782 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
783 yyrule - 1, yylno);
784 /* The symbols being reduced. */
785 for (yyi = 0; yyi < yynrhs; yyi++)
786 {
787 YYFPRINTF (stderr, " $%d = ", yyi + 1);
788 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
789 &(yyvsp[(yyi + 1) - (yynrhs)])
790 , format, name);
791 YYFPRINTF (stderr, "\n");
792 }
793}
794
795# define YY_REDUCE_PRINT(Rule) \
796do { \
797 if (yydebug) \
798 yy_reduce_print (yyvsp, Rule, format, name); \
799} while (YYID (0))
800
801/* Nonzero means print parse trace. It is left uninitialized so that
802 multiple parsers can coexist. */
803int yydebug;
804#else /* !YYDEBUG */
805# define YYDPRINTF(Args)
806# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
807# define YY_STACK_PRINT(Bottom, Top)
808# define YY_REDUCE_PRINT(Rule)
809#endif /* !YYDEBUG */
810
811
812/* YYINITDEPTH -- initial size of the parser's stacks. */
813#ifndef YYINITDEPTH
814# define YYINITDEPTH 200
815#endif
816
817/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
818 if the built-in stack extension method is used).
819
820 Do not make this value too large; the results are undefined if
821 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
822 evaluated with infinite-precision integer arithmetic. */
823
824#ifndef YYMAXDEPTH
825# define YYMAXDEPTH 10000
826#endif
827
828
829
830#if YYERROR_VERBOSE
831
832# ifndef yystrlen
833# if defined __GLIBC__ && defined _STRING_H
834# define yystrlen strlen
835# else
836/* Return the length of YYSTR. */
837#if (defined __STDC__ || defined __C99__FUNC__ \
838 || defined __cplusplus || defined _MSC_VER)
839static YYSIZE_T
840yystrlen (const char *yystr)
841#else
842static YYSIZE_T
843yystrlen (yystr)
844 const char *yystr;
845#endif
846{
847 YYSIZE_T yylen;
848 for (yylen = 0; yystr[yylen]; yylen++)
849 continue;
850 return yylen;
851}
852# endif
853# endif
854
855# ifndef yystpcpy
856# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
857# define yystpcpy stpcpy
858# else
859/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
860 YYDEST. */
861#if (defined __STDC__ || defined __C99__FUNC__ \
862 || defined __cplusplus || defined _MSC_VER)
863static char *
864yystpcpy (char *yydest, const char *yysrc)
865#else
866static char *
867yystpcpy (yydest, yysrc)
868 char *yydest;
869 const char *yysrc;
870#endif
871{
872 char *yyd = yydest;
873 const char *yys = yysrc;
874
875 while ((*yyd++ = *yys++) != '\0')
876 continue;
877
878 return yyd - 1;
879}
880# endif
881# endif
882
883# ifndef yytnamerr
884/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
885 quotes and backslashes, so that it's suitable for yyerror. The
886 heuristic is that double-quoting is unnecessary unless the string
887 contains an apostrophe, a comma, or backslash (other than
888 backslash-backslash). YYSTR is taken from yytname. If YYRES is
889 null, do not copy; instead, return the length of what the result
890 would have been. */
891static YYSIZE_T
892yytnamerr (char *yyres, const char *yystr)
893{
894 if (*yystr == '"')
895 {
896 YYSIZE_T yyn = 0;
897 char const *yyp = yystr;
898
899 for (;;)
900 switch (*++yyp)
901 {
902 case '\'':
903 case ',':
904 goto do_not_strip_quotes;
905
906 case '\\':
907 if (*++yyp != '\\')
908 goto do_not_strip_quotes;
909 /* Fall through. */
910 default:
911 if (yyres)
912 yyres[yyn] = *yyp;
913 yyn++;
914 break;
915
916 case '"':
917 if (yyres)
918 yyres[yyn] = '\0';
919 return yyn;
920 }
921 do_not_strip_quotes: ;
922 }
923
924 if (! yyres)
925 return yystrlen (yystr);
926
927 return yystpcpy (yyres, yystr) - yyres;
928}
929# endif
930
931/* Copy into YYRESULT an error message about the unexpected token
932 YYCHAR while in state YYSTATE. Return the number of bytes copied,
933 including the terminating null byte. If YYRESULT is null, do not
934 copy anything; just return the number of bytes that would be
935 copied. As a special case, return 0 if an ordinary "syntax error"
936 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
937 size calculation. */
938static YYSIZE_T
939yysyntax_error (char *yyresult, int yystate, int yychar)
940{
941 int yyn = yypact[yystate];
942
943 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
944 return 0;
945 else
946 {
947 int yytype = YYTRANSLATE (yychar);
948 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
949 YYSIZE_T yysize = yysize0;
950 YYSIZE_T yysize1;
951 int yysize_overflow = 0;
952 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
953 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
954 int yyx;
955
956# if 0
957 /* This is so xgettext sees the translatable formats that are
958 constructed on the fly. */
959 YY_("syntax error, unexpected %s");
960 YY_("syntax error, unexpected %s, expecting %s");
961 YY_("syntax error, unexpected %s, expecting %s or %s");
962 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
963 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
964# endif
965 char *yyfmt;
966 char const *yyf;
967 static char const yyunexpected[] = "syntax error, unexpected %s";
968 static char const yyexpecting[] = ", expecting %s";
969 static char const yyor[] = " or %s";
970 char yyformat[sizeof yyunexpected
971 + sizeof yyexpecting - 1
972 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
973 * (sizeof yyor - 1))];
974 char const *yyprefix = yyexpecting;
975
976 /* Start YYX at -YYN if negative to avoid negative indexes in
977 YYCHECK. */
978 int yyxbegin = yyn < 0 ? -yyn : 0;
979
980 /* Stay within bounds of both yycheck and yytname. */
981 int yychecklim = YYLAST - yyn + 1;
982 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
983 int yycount = 1;
984
985 yyarg[0] = yytname[yytype];
986 yyfmt = yystpcpy (yyformat, yyunexpected);
987
988 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
989 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
990 {
991 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
992 {
993 yycount = 1;
994 yysize = yysize0;
995 yyformat[sizeof yyunexpected - 1] = '\0';
996 break;
997 }
998 yyarg[yycount++] = yytname[yyx];
999 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1000 yysize_overflow |= (yysize1 < yysize);
1001 yysize = yysize1;
1002 yyfmt = yystpcpy (yyfmt, yyprefix);
1003 yyprefix = yyor;
1004 }
1005
1006 yyf = YY_(yyformat);
1007 yysize1 = yysize + yystrlen (yyf);
1008 yysize_overflow |= (yysize1 < yysize);
1009 yysize = yysize1;
1010
1011 if (yysize_overflow)
1012 return YYSIZE_MAXIMUM;
1013
1014 if (yyresult)
1015 {
1016 /* Avoid sprintf, as that infringes on the user's name space.
1017 Don't have undefined behavior even if the translation
1018 produced a string with the wrong number of "%s"s. */
1019 char *yyp = yyresult;
1020 int yyi = 0;
1021 while ((*yyp = *yyf) != '\0')
1022 {
1023 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1024 {
1025 yyp += yytnamerr (yyp, yyarg[yyi++]);
1026 yyf += 2;
1027 }
1028 else
1029 {
1030 yyp++;
1031 yyf++;
1032 }
1033 }
1034 }
1035 return yysize;
1036 }
1037}
1038#endif /* YYERROR_VERBOSE */
1039
1040
1041/*-----------------------------------------------.
1042| Release the memory associated to this symbol. |
1043`-----------------------------------------------*/
1044
1045/*ARGSUSED*/
1046#if (defined __STDC__ || defined __C99__FUNC__ \
1047 || defined __cplusplus || defined _MSC_VER)
1048static void
1049yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct list_head *format, char *name)
1050#else
1051static void
1052yydestruct (yymsg, yytype, yyvaluep, format, name)
1053 const char *yymsg;
1054 int yytype;
1055 YYSTYPE *yyvaluep;
1056 struct list_head *format;
1057 char *name;
1058#endif
1059{
1060 YYUSE (yyvaluep);
1061 YYUSE (format);
1062 YYUSE (name);
1063
1064 if (!yymsg)
1065 yymsg = "Deleting";
1066 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1067
1068 switch (yytype)
1069 {
1070
1071 default:
1072 break;
1073 }
1074}
1075
1076/* Prevent warnings from -Wmissing-prototypes. */
1077#ifdef YYPARSE_PARAM
1078#if defined __STDC__ || defined __cplusplus
1079int yyparse (void *YYPARSE_PARAM);
1080#else
1081int yyparse ();
1082#endif
1083#else /* ! YYPARSE_PARAM */
1084#if defined __STDC__ || defined __cplusplus
1085int yyparse (struct list_head *format, char *name);
1086#else
1087int yyparse ();
1088#endif
1089#endif /* ! YYPARSE_PARAM */
1090
1091
1092/* The lookahead symbol. */
1093int yychar;
1094
1095/* The semantic value of the lookahead symbol. */
1096YYSTYPE yylval;
1097
1098/* Number of syntax errors so far. */
1099int yynerrs;
1100
1101
1102
1103/*-------------------------.
1104| yyparse or yypush_parse. |
1105`-------------------------*/
1106
1107#ifdef YYPARSE_PARAM
1108#if (defined __STDC__ || defined __C99__FUNC__ \
1109 || defined __cplusplus || defined _MSC_VER)
1110int
1111yyparse (void *YYPARSE_PARAM)
1112#else
1113int
1114yyparse (YYPARSE_PARAM)
1115 void *YYPARSE_PARAM;
1116#endif
1117#else /* ! YYPARSE_PARAM */
1118#if (defined __STDC__ || defined __C99__FUNC__ \
1119 || defined __cplusplus || defined _MSC_VER)
1120int
1121yyparse (struct list_head *format, char *name)
1122#else
1123int
1124yyparse (format, name)
1125 struct list_head *format;
1126 char *name;
1127#endif
1128#endif
1129{
1130
1131
1132 int yystate;
1133 /* Number of tokens to shift before error messages enabled. */
1134 int yyerrstatus;
1135
1136 /* The stacks and their tools:
1137 `yyss': related to states.
1138 `yyvs': related to semantic values.
1139
1140 Refer to the stacks thru separate pointers, to allow yyoverflow
1141 to reallocate them elsewhere. */
1142
1143 /* The state stack. */
1144 yytype_int16 yyssa[YYINITDEPTH];
1145 yytype_int16 *yyss;
1146 yytype_int16 *yyssp;
1147
1148 /* The semantic value stack. */
1149 YYSTYPE yyvsa[YYINITDEPTH];
1150 YYSTYPE *yyvs;
1151 YYSTYPE *yyvsp;
1152
1153 YYSIZE_T yystacksize;
1154
1155 int yyn;
1156 int yyresult;
1157 /* Lookahead token as an internal (translated) token number. */
1158 int yytoken;
1159 /* The variables used to return semantic value and location from the
1160 action routines. */
1161 YYSTYPE yyval;
1162
1163#if YYERROR_VERBOSE
1164 /* Buffer for error messages, and its allocated size. */
1165 char yymsgbuf[128];
1166 char *yymsg = yymsgbuf;
1167 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1168#endif
1169
1170#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1171
1172 /* The number of symbols on the RHS of the reduced rule.
1173 Keep to zero when no symbol should be popped. */
1174 int yylen = 0;
1175
1176 yytoken = 0;
1177 yyss = yyssa;
1178 yyvs = yyvsa;
1179 yystacksize = YYINITDEPTH;
1180
1181 YYDPRINTF ((stderr, "Starting parse\n"));
1182
1183 yystate = 0;
1184 yyerrstatus = 0;
1185 yynerrs = 0;
1186 yychar = YYEMPTY; /* Cause a token to be read. */
1187
1188 /* Initialize stack pointers.
1189 Waste one element of value and location stack
1190 so that they stay on the same level as the state stack.
1191 The wasted elements are never initialized. */
1192 yyssp = yyss;
1193 yyvsp = yyvs;
1194
1195 goto yysetstate;
1196
1197/*------------------------------------------------------------.
1198| yynewstate -- Push a new state, which is found in yystate. |
1199`------------------------------------------------------------*/
1200 yynewstate:
1201 /* In all cases, when you get here, the value and location stacks
1202 have just been pushed. So pushing a state here evens the stacks. */
1203 yyssp++;
1204
1205 yysetstate:
1206 *yyssp = yystate;
1207
1208 if (yyss + yystacksize - 1 <= yyssp)
1209 {
1210 /* Get the current used size of the three stacks, in elements. */
1211 YYSIZE_T yysize = yyssp - yyss + 1;
1212
1213#ifdef yyoverflow
1214 {
1215 /* Give user a chance to reallocate the stack. Use copies of
1216 these so that the &'s don't force the real ones into
1217 memory. */
1218 YYSTYPE *yyvs1 = yyvs;
1219 yytype_int16 *yyss1 = yyss;
1220
1221 /* Each stack pointer address is followed by the size of the
1222 data in use in that stack, in bytes. This used to be a
1223 conditional around just the two extra args, but that might
1224 be undefined if yyoverflow is a macro. */
1225 yyoverflow (YY_("memory exhausted"),
1226 &yyss1, yysize * sizeof (*yyssp),
1227 &yyvs1, yysize * sizeof (*yyvsp),
1228 &yystacksize);
1229
1230 yyss = yyss1;
1231 yyvs = yyvs1;
1232 }
1233#else /* no yyoverflow */
1234# ifndef YYSTACK_RELOCATE
1235 goto yyexhaustedlab;
1236# else
1237 /* Extend the stack our own way. */
1238 if (YYMAXDEPTH <= yystacksize)
1239 goto yyexhaustedlab;
1240 yystacksize *= 2;
1241 if (YYMAXDEPTH < yystacksize)
1242 yystacksize = YYMAXDEPTH;
1243
1244 {
1245 yytype_int16 *yyss1 = yyss;
1246 union yyalloc *yyptr =
1247 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1248 if (! yyptr)
1249 goto yyexhaustedlab;
1250 YYSTACK_RELOCATE (yyss_alloc, yyss);
1251 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1252# undef YYSTACK_RELOCATE
1253 if (yyss1 != yyssa)
1254 YYSTACK_FREE (yyss1);
1255 }
1256# endif
1257#endif /* no yyoverflow */
1258
1259 yyssp = yyss + yysize - 1;
1260 yyvsp = yyvs + yysize - 1;
1261
1262 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1263 (unsigned long int) yystacksize));
1264
1265 if (yyss + yystacksize - 1 <= yyssp)
1266 YYABORT;
1267 }
1268
1269 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1270
1271 if (yystate == YYFINAL)
1272 YYACCEPT;
1273
1274 goto yybackup;
1275
1276/*-----------.
1277| yybackup. |
1278`-----------*/
1279yybackup:
1280
1281 /* Do appropriate processing given the current state. Read a
1282 lookahead token if we need one and don't already have one. */
1283
1284 /* First try to decide what to do without reference to lookahead token. */
1285 yyn = yypact[yystate];
1286 if (yyn == YYPACT_NINF)
1287 goto yydefault;
1288
1289 /* Not known => get a lookahead token if don't already have one. */
1290
1291 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1292 if (yychar == YYEMPTY)
1293 {
1294 YYDPRINTF ((stderr, "Reading a token: "));
1295 yychar = YYLEX;
1296 }
1297
1298 if (yychar <= YYEOF)
1299 {
1300 yychar = yytoken = YYEOF;
1301 YYDPRINTF ((stderr, "Now at end of input.\n"));
1302 }
1303 else
1304 {
1305 yytoken = YYTRANSLATE (yychar);
1306 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1307 }
1308
1309 /* If the proper action on seeing token YYTOKEN is to reduce or to
1310 detect an error, take that action. */
1311 yyn += yytoken;
1312 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1313 goto yydefault;
1314 yyn = yytable[yyn];
1315 if (yyn <= 0)
1316 {
1317 if (yyn == 0 || yyn == YYTABLE_NINF)
1318 goto yyerrlab;
1319 yyn = -yyn;
1320 goto yyreduce;
1321 }
1322
1323 /* Count tokens shifted since error; after three, turn off error
1324 status. */
1325 if (yyerrstatus)
1326 yyerrstatus--;
1327
1328 /* Shift the lookahead token. */
1329 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1330
1331 /* Discard the shifted token. */
1332 yychar = YYEMPTY;
1333
1334 yystate = yyn;
1335 *++yyvsp = yylval;
1336
1337 goto yynewstate;
1338
1339
1340/*-----------------------------------------------------------.
1341| yydefault -- do the default action for the current state. |
1342`-----------------------------------------------------------*/
1343yydefault:
1344 yyn = yydefact[yystate];
1345 if (yyn == 0)
1346 goto yyerrlab;
1347 goto yyreduce;
1348
1349
1350/*-----------------------------.
1351| yyreduce -- Do a reduction. |
1352`-----------------------------*/
1353yyreduce:
1354 /* yyn is the number of a rule to reduce with. */
1355 yylen = yyr2[yyn];
1356
1357 /* If YYLEN is nonzero, implement the default value of the action:
1358 `$$ = $1'.
1359
1360 Otherwise, the following line sets YYVAL to garbage.
1361 This behavior is undocumented and Bison
1362 users should not rely upon it. Assigning to YYVAL
1363 unconditionally makes the parser a bit smaller, and it avoids a
1364 GCC warning that YYVAL may be used uninitialized. */
1365 yyval = yyvsp[1-yylen];
1366
1367
1368 YY_REDUCE_PRINT (yyn);
1369 switch (yyn)
1370 {
1371 case 4:
1372
1373/* Line 1464 of yacc.c */
1374#line 45 "util/pmu.y"
1375 {
1376 ABORT_ON(perf_pmu__new_format(format, name,
1377 PERF_PMU_FORMAT_VALUE_CONFIG,
1378 (yyvsp[(3) - (3)].bits)));
1379;}
1380 break;
1381
1382 case 5:
1383
1384/* Line 1464 of yacc.c */
1385#line 52 "util/pmu.y"
1386 {
1387 ABORT_ON(perf_pmu__new_format(format, name,
1388 PERF_PMU_FORMAT_VALUE_CONFIG1,
1389 (yyvsp[(3) - (3)].bits)));
1390;}
1391 break;
1392
1393 case 6:
1394
1395/* Line 1464 of yacc.c */
1396#line 59 "util/pmu.y"
1397 {
1398 ABORT_ON(perf_pmu__new_format(format, name,
1399 PERF_PMU_FORMAT_VALUE_CONFIG2,
1400 (yyvsp[(3) - (3)].bits)));
1401;}
1402 break;
1403
1404 case 7:
1405
1406/* Line 1464 of yacc.c */
1407#line 67 "util/pmu.y"
1408 {
1409 bitmap_or((yyval.bits), (yyvsp[(1) - (3)].bits), (yyvsp[(3) - (3)].bits), 64);
1410;}
1411 break;
1412
1413 case 8:
1414
1415/* Line 1464 of yacc.c */
1416#line 72 "util/pmu.y"
1417 {
1418 memcpy((yyval.bits), (yyvsp[(1) - (1)].bits), sizeof((yyvsp[(1) - (1)].bits)));
1419;}
1420 break;
1421
1422 case 9:
1423
1424/* Line 1464 of yacc.c */
1425#line 78 "util/pmu.y"
1426 {
1427 perf_pmu__set_format((yyval.bits), (yyvsp[(1) - (3)].num), (yyvsp[(3) - (3)].num));
1428;}
1429 break;
1430
1431 case 10:
1432
1433/* Line 1464 of yacc.c */
1434#line 83 "util/pmu.y"
1435 {
1436 perf_pmu__set_format((yyval.bits), (yyvsp[(1) - (1)].num), 0);
1437;}
1438 break;
1439
1440
1441
1442/* Line 1464 of yacc.c */
1443#line 1444 "util/pmu-bison.c"
1444 default: break;
1445 }
1446 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1447
1448 YYPOPSTACK (yylen);
1449 yylen = 0;
1450 YY_STACK_PRINT (yyss, yyssp);
1451
1452 *++yyvsp = yyval;
1453
1454 /* Now `shift' the result of the reduction. Determine what state
1455 that goes to, based on the state we popped back to and the rule
1456 number reduced by. */
1457
1458 yyn = yyr1[yyn];
1459
1460 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1461 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1462 yystate = yytable[yystate];
1463 else
1464 yystate = yydefgoto[yyn - YYNTOKENS];
1465
1466 goto yynewstate;
1467
1468
1469/*------------------------------------.
1470| yyerrlab -- here on detecting error |
1471`------------------------------------*/
1472yyerrlab:
1473 /* If not already recovering from an error, report this error. */
1474 if (!yyerrstatus)
1475 {
1476 ++yynerrs;
1477#if ! YYERROR_VERBOSE
1478 yyerror (format, name, YY_("syntax error"));
1479#else
1480 {
1481 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1482 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1483 {
1484 YYSIZE_T yyalloc = 2 * yysize;
1485 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1486 yyalloc = YYSTACK_ALLOC_MAXIMUM;
1487 if (yymsg != yymsgbuf)
1488 YYSTACK_FREE (yymsg);
1489 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1490 if (yymsg)
1491 yymsg_alloc = yyalloc;
1492 else
1493 {
1494 yymsg = yymsgbuf;
1495 yymsg_alloc = sizeof yymsgbuf;
1496 }
1497 }
1498
1499 if (0 < yysize && yysize <= yymsg_alloc)
1500 {
1501 (void) yysyntax_error (yymsg, yystate, yychar);
1502 yyerror (format, name, yymsg);
1503 }
1504 else
1505 {
1506 yyerror (format, name, YY_("syntax error"));
1507 if (yysize != 0)
1508 goto yyexhaustedlab;
1509 }
1510 }
1511#endif
1512 }
1513
1514
1515
1516 if (yyerrstatus == 3)
1517 {
1518 /* If just tried and failed to reuse lookahead token after an
1519 error, discard it. */
1520
1521 if (yychar <= YYEOF)
1522 {
1523 /* Return failure if at end of input. */
1524 if (yychar == YYEOF)
1525 YYABORT;
1526 }
1527 else
1528 {
1529 yydestruct ("Error: discarding",
1530 yytoken, &yylval, format, name);
1531 yychar = YYEMPTY;
1532 }
1533 }
1534
1535 /* Else will try to reuse lookahead token after shifting the error
1536 token. */
1537 goto yyerrlab1;
1538
1539
1540/*---------------------------------------------------.
1541| yyerrorlab -- error raised explicitly by YYERROR. |
1542`---------------------------------------------------*/
1543yyerrorlab:
1544
1545 /* Pacify compilers like GCC when the user code never invokes
1546 YYERROR and the label yyerrorlab therefore never appears in user
1547 code. */
1548 if (/*CONSTCOND*/ 0)
1549 goto yyerrorlab;
1550
1551 /* Do not reclaim the symbols of the rule which action triggered
1552 this YYERROR. */
1553 YYPOPSTACK (yylen);
1554 yylen = 0;
1555 YY_STACK_PRINT (yyss, yyssp);
1556 yystate = *yyssp;
1557 goto yyerrlab1;
1558
1559
1560/*-------------------------------------------------------------.
1561| yyerrlab1 -- common code for both syntax error and YYERROR. |
1562`-------------------------------------------------------------*/
1563yyerrlab1:
1564 yyerrstatus = 3; /* Each real token shifted decrements this. */
1565
1566 for (;;)
1567 {
1568 yyn = yypact[yystate];
1569 if (yyn != YYPACT_NINF)
1570 {
1571 yyn += YYTERROR;
1572 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1573 {
1574 yyn = yytable[yyn];
1575 if (0 < yyn)
1576 break;
1577 }
1578 }
1579
1580 /* Pop the current state because it cannot handle the error token. */
1581 if (yyssp == yyss)
1582 YYABORT;
1583
1584
1585 yydestruct ("Error: popping",
1586 yystos[yystate], yyvsp, format, name);
1587 YYPOPSTACK (1);
1588 yystate = *yyssp;
1589 YY_STACK_PRINT (yyss, yyssp);
1590 }
1591
1592 *++yyvsp = yylval;
1593
1594
1595 /* Shift the error token. */
1596 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1597
1598 yystate = yyn;
1599 goto yynewstate;
1600
1601
1602/*-------------------------------------.
1603| yyacceptlab -- YYACCEPT comes here. |
1604`-------------------------------------*/
1605yyacceptlab:
1606 yyresult = 0;
1607 goto yyreturn;
1608
1609/*-----------------------------------.
1610| yyabortlab -- YYABORT comes here. |
1611`-----------------------------------*/
1612yyabortlab:
1613 yyresult = 1;
1614 goto yyreturn;
1615
1616#if !defined(yyoverflow) || YYERROR_VERBOSE
1617/*-------------------------------------------------.
1618| yyexhaustedlab -- memory exhaustion comes here. |
1619`-------------------------------------------------*/
1620yyexhaustedlab:
1621 yyerror (format, name, YY_("memory exhausted"));
1622 yyresult = 2;
1623 /* Fall through. */
1624#endif
1625
1626yyreturn:
1627 if (yychar != YYEMPTY)
1628 yydestruct ("Cleanup: discarding lookahead",
1629 yytoken, &yylval, format, name);
1630 /* Do not reclaim the symbols of the rule which action triggered
1631 this YYABORT or YYACCEPT. */
1632 YYPOPSTACK (yylen);
1633 YY_STACK_PRINT (yyss, yyssp);
1634 while (yyssp != yyss)
1635 {
1636 yydestruct ("Cleanup: popping",
1637 yystos[*yyssp], yyvsp, format, name);
1638 YYPOPSTACK (1);
1639 }
1640#ifndef yyoverflow
1641 if (yyss != yyssa)
1642 YYSTACK_FREE (yyss);
1643#endif
1644#if YYERROR_VERBOSE
1645 if (yymsg != yymsgbuf)
1646 YYSTACK_FREE (yymsg);
1647#endif
1648 /* Make sure YYID is used. */
1649 return YYID (yyresult);
1650}
1651
1652
1653
1654/* Line 1684 of yacc.c */
1655#line 87 "util/pmu.y"
1656
1657
1658void perf_pmu_error(struct list_head *list __used,
1659 char *name __used,
1660 char const *msg __used)
1661{
1662}
1663
generated by cgit v1.2.2 (git 2.25.0) at 2026-04-24 03:46:54 -0400