libcpu/i386_parse.c

   1 /* A Bison parser, made by GNU Bison 2.5.  */
   2
   3 /* Bison implementation for Yacc-like parsers in C
   4
   5       Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
   6
   7    This program is free software: you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation, either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* As a special exception, you may create a larger work that contains
  21    part or all of the Bison parser skeleton and distribute that work
  22    under terms of your choice, so long as that work isn't itself a
  23    parser generator using the skeleton or a modified version thereof
  24    as a parser skeleton.  Alternatively, if you modify or redistribute
  25    the parser skeleton itself, you may (at your option) remove this
  26    special exception, which will cause the skeleton and the resulting
  27    Bison output files to be licensed under the GNU General Public
  28    License without this special exception.
  29
  30    This special exception was added by the Free Software Foundation in
  31    version 2.2 of Bison.  */
  32
  33 /* C LALR(1) parser skeleton written by Richard Stallman, by
  34    simplifying the original so-called "semantic" parser.  */
  35
  36 /* All symbols defined below should begin with yy or YY, to avoid
  37    infringing on user name space.  This should be done even for local
  38    variables, as they might otherwise be expanded by user macros.
  39    There are some unavoidable exceptions within include files to
  40    define necessary library symbols; they are noted "INFRINGES ON
  41    USER NAME SPACE" below.  */
  42
  43 /* Identify Bison output.  */
  44 #define YYBISON 1
  45
  46 /* Bison version.  */
  47 #define YYBISON_VERSION "2.5"
  48
  49 /* Skeleton name.  */
  50 #define YYSKELETON_NAME "yacc.c"
  51
  52 /* Pure parsers.  */
  53 #define YYPURE 0
  54
  55 /* Push parsers.  */
  56 #define YYPUSH 0
  57
  58 /* Pull parsers.  */
  59 #define YYPULL 1
  60
  61 /* Using locations.  */
  62 #define YYLSP_NEEDED 0
  63
  64 /* Substitute the variable and function names.  */
  65 #define yyparse         i386_parse
  66 #define yylex           i386_lex
  67 #define yyerror         i386_error
  68 #define yylval          i386_lval
  69 #define yychar          i386_char
  70 #define yydebug         i386_debug
  71 #define yynerrs         i386_nerrs
  72
  73
  74 /* Copy the first part of user declarations.  */
  75
  76 /* Line 268 of yacc.c  */
  77 #line 1 "i386_parse.y"
  78
  79 /* Parser for i386 CPU description.
  80    Copyright (C) 2004, 2005, 2007, 2008, 2009 Red Hat, Inc.
  81    Written by Ulrich Drepper <drepper@redhat.com>, 2004.
  82
  83    Red Hat elfutils is free software; you can redistribute it and/or modify
  84    it under the terms of the GNU General Public License as published by the
  85    Free Software Foundation; version 2 of the License.
  86
  87    Red Hat elfutils is distributed in the hope that it will be useful, but
  88    WITHOUT ANY WARRANTY; without even the implied warranty of
  89    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  90    General Public License for more details.
  91
  92    You should have received a copy of the GNU General Public License along
  93    with Red Hat elfutils; if not, write to the Free Software Foundation,
  94    Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
  95
  96    Red Hat elfutils is an included package of the Open Invention Network.
  97    An included package of the Open Invention Network is a package for which
  98    Open Invention Network licensees cross-license their patents.  No patent
  99    license is granted, either expressly or impliedly, by designation as an
 100    included package.  Should you wish to participate in the Open Invention
 101    Network licensing program, please visit www.openinventionnetwork.com
 102    <http://www.openinventionnetwork.com>.  */
 103
 104 #ifdef HAVE_CONFIG_H
 105 # include <config.h>
 106 #endif
 107
 108 #include <assert.h>
 109 #include <ctype.h>
 110 #include <errno.h>
 111 #include <error.h>
 112 #include <inttypes.h>
 113 #include <libintl.h>
 114 #include <math.h>
 115 #include <obstack.h>
 116 #include <search.h>
 117 #include <stdbool.h>
 118 #include <stdio.h>
 119 #include <stdlib.h>
 120 #include <string.h>
 121 #include <sys/param.h>
 122
 123 #include <system.h>
 124
 125 #define obstack_chunk_alloc xmalloc
 126 #define obstack_chunk_free free
 127
 128 /* The error handler.  */
 129 static void yyerror (const char *s);
 130
 131 extern int yylex (void);
 132 extern int i386_lineno;
 133 extern char *infname;
 134
 135
 136 struct known_bitfield
 137 {
 138   char *name;
 139   unsigned long int bits;
 140   int tmp;
 141 };
 142
 143
 144 struct bitvalue
 145 {
 146   enum bittype { zeroone, field, failure } type;
 147   union
 148   {
 149     unsigned int value;
 150     struct known_bitfield *field;
 151   };
 152   struct bitvalue *next;
 153 };
 154
 155
 156 struct argname
 157 {
 158   enum nametype { string, nfield } type;
 159   union
 160   {
 161     char *str;
 162     struct known_bitfield *field;
 163   };
 164   struct argname *next;
 165 };
 166
 167
 168 struct argument
 169 {
 170   struct argname *name;
 171   struct argument *next;
 172 };
 173
 174
 175 struct instruction
 176 {
 177   /* The byte encoding.  */
 178   struct bitvalue *bytes;
 179
 180   /* Prefix possible.  */
 181   int repe;
 182   int rep;
 183
 184   /* Mnemonic.  */
 185   char *mnemonic;
 186
 187   /* Suffix.  */
 188   enum { suffix_none = 0, suffix_w, suffix_w0, suffix_W, suffix_tttn,
 189          suffix_w1, suffix_W1, suffix_D } suffix;
 190
 191   /* Flag set if modr/m is used.  */
 192   int modrm;
 193
 194   /* Operands.  */
 195   struct operand
 196   {
 197     char *fct;
 198     char *str;
 199     int off1;
 200     int off2;
 201     int off3;
 202   } operands[3];
 203
 204   struct instruction *next;
 205 };
 206
 207
 208 struct synonym
 209 {
 210   char *from;
 211   char *to;
 212 };
 213
 214
 215 struct suffix
 216 {
 217   char *name;
 218   int idx;
 219 };
 220
 221
 222 struct argstring
 223 {
 224   char *str;
 225   int idx;
 226   int off;
 227 };
 228
 229
 230 static struct known_bitfield ax_reg =
 231   {
 232     .name = "ax", .bits = 0, .tmp = 0
 233   };
 234
 235 static struct known_bitfield dx_reg =
 236   {
 237     .name = "dx", .bits = 0, .tmp = 0
 238   };
 239
 240 static struct known_bitfield di_reg =
 241   {
 242     .name = "es_di", .bits = 0, .tmp = 0
 243   };
 244
 245 static struct known_bitfield si_reg =
 246   {
 247     .name = "ds_si", .bits = 0, .tmp = 0
 248   };
 249
 250 static struct known_bitfield bx_reg =
 251   {
 252     .name = "ds_bx", .bits = 0, .tmp = 0
 253   };
 254
 255
 256 static int bitfield_compare (const void *p1, const void *p2);
 257 static void new_bitfield (char *name, unsigned long int num);
 258 static void check_bits (struct bitvalue *value);
 259 static int check_duplicates (struct bitvalue *val);
 260 static int check_argsdef (struct bitvalue *bitval, struct argument *args);
 261 static int check_bitsused (struct bitvalue *bitval,
 262                            struct known_bitfield *suffix,
 263                            struct argument *args);
 264 static struct argname *combine (struct argname *name);
 265 static void fillin_arg (struct bitvalue *bytes, struct argname *name,
 266                         struct instruction *instr, int n);
 267 static void find_numbers (void);
 268 static int compare_syn (const void *p1, const void *p2);
 269 static int compare_suf (const void *p1, const void *p2);
 270 static void instrtable_out (void);
 271 #if 0
 272 static void create_mnemonic_table (void);
 273 #endif
 274
 275 static void *bitfields;
 276 static struct instruction *instructions;
 277 static size_t ninstructions;
 278 static void *synonyms;
 279 static void *suffixes;
 280 static int nsuffixes;
 281 static void *mnemonics;
 282 size_t nmnemonics;
 283 extern FILE *outfile;
 284
 285 /* Number of bits used mnemonics.  */
 286 #if 0
 287 static size_t best_mnemonic_bits;
 288 #endif
 289
 290
 291 /* Line 268 of yacc.c  */
 292 #line 293 "i386_parse.c"
 293
 294 /* Enabling traces.  */
 295 #ifndef YYDEBUG
 296 # define YYDEBUG 0
 297 #endif
 298
 299 /* Enabling verbose error messages.  */
 300 #ifdef YYERROR_VERBOSE
 301 # undef YYERROR_VERBOSE
 302 # define YYERROR_VERBOSE 1
 303 #else
 304 # define YYERROR_VERBOSE 0
 305 #endif
 306
 307 /* Enabling the token table.  */
 308 #ifndef YYTOKEN_TABLE
 309 # define YYTOKEN_TABLE 0
 310 #endif
 311
 312
 313 /* Tokens.  */
 314 #ifndef YYTOKENTYPE
 315 # define YYTOKENTYPE
 316    /* Put the tokens into the symbol table, so that GDB and other debuggers
 317       know about them.  */
 318    enum yytokentype {
 319      kMASK = 258,
 320      kPREFIX = 259,
 321      kSUFFIX = 260,
 322      kSYNONYM = 261,
 323      kID = 262,
 324      kNUMBER = 263,
 325      kPERCPERC = 264,
 326      kBITFIELD = 265,
 327      kCHAR = 266,
 328      kSPACE = 267
 329    };
 330 #endif
 331 /* Tokens.  */
 332 #define kMASK 258
 333 #define kPREFIX 259
 334 #define kSUFFIX 260
 335 #define kSYNONYM 261
 336 #define kID 262
 337 #define kNUMBER 263
 338 #define kPERCPERC 264
 339 #define kBITFIELD 265
 340 #define kCHAR 266
 341 #define kSPACE 267
 342
 343
 344
 345
 346 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 347 typedef union YYSTYPE
 348 {
 349
 350 /* Line 293 of yacc.c  */
 351 #line 214 "i386_parse.y"
 352
 353   unsigned long int num;
 354   char *str;
 355   char ch;
 356   struct known_bitfield *field;
 357   struct bitvalue *bit;
 358   struct argname *name;
 359   struct argument *arg;
 360
 361
 362
 363 /* Line 293 of yacc.c  */
 364 #line 365 "i386_parse.c"
 365 } YYSTYPE;
 366 # define YYSTYPE_IS_TRIVIAL 1
 367 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 368 # define YYSTYPE_IS_DECLARED 1
 369 #endif
 370
 371
 372 /* Copy the second part of user declarations.  */
 373
 374
 375 /* Line 343 of yacc.c  */
 376 #line 377 "i386_parse.c"
 377
 378 #ifdef short
 379 # undef short
 380 #endif
 381
 382 #ifdef YYTYPE_UINT8
 383 typedef YYTYPE_UINT8 yytype_uint8;
 384 #else
 385 typedef unsigned char yytype_uint8;
 386 #endif
 387
 388 #ifdef YYTYPE_INT8
 389 typedef YYTYPE_INT8 yytype_int8;
 390 #elif (defined __STDC__ || defined __C99__FUNC__ \
 391      || defined __cplusplus || defined _MSC_VER)
 392 typedef signed char yytype_int8;
 393 #else
 394 typedef short int yytype_int8;
 395 #endif
 396
 397 #ifdef YYTYPE_UINT16
 398 typedef YYTYPE_UINT16 yytype_uint16;
 399 #else
 400 typedef unsigned short int yytype_uint16;
 401 #endif
 402
 403 #ifdef YYTYPE_INT16
 404 typedef YYTYPE_INT16 yytype_int16;
 405 #else
 406 typedef short int yytype_int16;
 407 #endif
 408
 409 #ifndef YYSIZE_T
 410 # ifdef __SIZE_TYPE__
 411 #  define YYSIZE_T __SIZE_TYPE__
 412 # elif defined size_t
 413 #  define YYSIZE_T size_t
 414 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
 415      || defined __cplusplus || defined _MSC_VER)
 416 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 417 #  define YYSIZE_T size_t
 418 # else
 419 #  define YYSIZE_T unsigned int
 420 # endif
 421 #endif
 422
 423 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 424
 425 #ifndef YY_
 426 # if defined YYENABLE_NLS && YYENABLE_NLS
 427 #  if ENABLE_NLS
 428 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 429 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
 430 #  endif
 431 # endif
 432 # ifndef YY_
 433 #  define YY_(msgid) msgid
 434 # endif
 435 #endif
 436
 437 /* Suppress unused-variable warnings by "using" E.  */
 438 #if ! defined lint || defined __GNUC__
 439 # define YYUSE(e) ((void) (e))
 440 #else
 441 # define YYUSE(e) /* empty */
 442 #endif
 443
 444 /* Identity function, used to suppress warnings about constant conditions.  */
 445 #ifndef lint
 446 # define YYID(n) (n)
 447 #else
 448 #if (defined __STDC__ || defined __C99__FUNC__ \
 449      || defined __cplusplus || defined _MSC_VER)
 450 static int
 451 YYID (int yyi)
 452 #else
 453 static int
 454 YYID (yyi)
 455     int yyi;
 456 #endif
 457 {
 458   return yyi;
 459 }
 460 #endif
 461
 462 #if ! defined yyoverflow || YYERROR_VERBOSE
 463
 464 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 465
 466 # ifdef YYSTACK_USE_ALLOCA
 467 #  if YYSTACK_USE_ALLOCA
 468 #   ifdef __GNUC__
 469 #    define YYSTACK_ALLOC __builtin_alloca
 470 #   elif defined __BUILTIN_VA_ARG_INCR
 471 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 472 #   elif defined _AIX
 473 #    define YYSTACK_ALLOC __alloca
 474 #   elif defined _MSC_VER
 475 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 476 #    define alloca _alloca
 477 #   else
 478 #    define YYSTACK_ALLOC alloca
 479 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
 480      || defined __cplusplus || defined _MSC_VER)
 481 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 482 #     ifndef EXIT_SUCCESS
 483 #      define EXIT_SUCCESS 0
 484 #     endif
 485 #    endif
 486 #   endif
 487 #  endif
 488 # endif
 489
 490 # ifdef YYSTACK_ALLOC
 491    /* Pacify GCC's `empty if-body' warning.  */
 492 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
 493 #  ifndef YYSTACK_ALLOC_MAXIMUM
 494     /* The OS might guarantee only one guard page at the bottom of the stack,
 495        and a page size can be as small as 4096 bytes.  So we cannot safely
 496        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 497        to allow for a few compiler-allocated temporary stack slots.  */
 498 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 499 #  endif
 500 # else
 501 #  define YYSTACK_ALLOC YYMALLOC
 502 #  define YYSTACK_FREE YYFREE
 503 #  ifndef YYSTACK_ALLOC_MAXIMUM
 504 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 505 #  endif
 506 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
 507        && ! ((defined YYMALLOC || defined malloc) \
 508              && (defined YYFREE || defined free)))
 509 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 510 #   ifndef EXIT_SUCCESS
 511 #    define EXIT_SUCCESS 0
 512 #   endif
 513 #  endif
 514 #  ifndef YYMALLOC
 515 #   define YYMALLOC malloc
 516 #   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
 517      || defined __cplusplus || defined _MSC_VER)
 518 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 519 #   endif
 520 #  endif
 521 #  ifndef YYFREE
 522 #   define YYFREE free
 523 #   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
 524      || defined __cplusplus || defined _MSC_VER)
 525 void free (void *); /* INFRINGES ON USER NAME SPACE */
 526 #   endif
 527 #  endif
 528 # endif
 529 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 530
 531
 532 #if (! defined yyoverflow \
 533      && (! defined __cplusplus \
 534          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 535
 536 /* A type that is properly aligned for any stack member.  */
 537 union yyalloc
 538 {
 539   yytype_int16 yyss_alloc;
 540   YYSTYPE yyvs_alloc;
 541 };
 542
 543 /* The size of the maximum gap between one aligned stack and the next.  */
 544 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 545
 546 /* The size of an array large to enough to hold all stacks, each with
 547    N elements.  */
 548 # define YYSTACK_BYTES(N) \
 549      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
 550       + YYSTACK_GAP_MAXIMUM)
 551
 552 # define YYCOPY_NEEDED 1
 553
 554 /* Relocate STACK from its old location to the new one.  The
 555    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 556    elements in the stack, and YYPTR gives the new location of the
 557    stack.  Advance YYPTR to a properly aligned location for the next
 558    stack.  */
 559 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
 560     do                                                                  \
 561       {                                                                 \
 562         YYSIZE_T yynewbytes;                                            \
 563         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
 564         Stack = &yyptr->Stack_alloc;                                    \
 565         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 566         yyptr += yynewbytes / sizeof (*yyptr);                          \
 567       }                                                                 \
 568     while (YYID (0))
 569
 570 #endif
 571
 572 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
 573 /* Copy COUNT objects from FROM to TO.  The source and destination do
 574    not overlap.  */
 575 # ifndef YYCOPY
 576 #  if defined __GNUC__ && 1 < __GNUC__
 577 #   define YYCOPY(To, From, Count) \
 578       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 579 #  else
 580 #   define YYCOPY(To, From, Count)              \
 581       do                                        \
 582         {                                       \
 583           YYSIZE_T yyi;                         \
 584           for (yyi = 0; yyi < (Count); yyi++)   \
 585             (To)[yyi] = (From)[yyi];            \
 586         }                                       \
 587       while (YYID (0))
 588 #  endif
 589 # endif
 590 #endif /* !YYCOPY_NEEDED */
 591
 592 /* YYFINAL -- State number of the termination state.  */
 593 #define YYFINAL  12
 594 /* YYLAST -- Last index in YYTABLE.  */
 595 #define YYLAST   37
 596
 597 /* YYNTOKENS -- Number of terminals.  */
 598 #define YYNTOKENS  18
 599 /* YYNNTS -- Number of nonterminals.  */
 600 #define YYNNTS  14
 601 /* YYNRULES -- Number of rules.  */
 602 #define YYNRULES  32
 603 /* YYNRULES -- Number of states.  */
 604 #define YYNSTATES  49
 605
 606 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 607 #define YYUNDEFTOK  2
 608 #define YYMAXUTOK   267
 609
 610 #define YYTRANSLATE(YYX)                                                \
 611   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 612
 613 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 614 static const yytype_uint8 yytranslate[] =
 615 {
 616        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 617       13,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 618        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 619        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 620        2,     2,     2,     2,    15,     2,     2,     2,    16,    17,
 621        2,     2,     2,     2,     2,     2,     2,     2,    14,     2,
 622        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 623        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 624        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 625        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 626        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 627        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 628        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 629        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 630        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 631        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 632        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 633        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 634        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 635        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 636        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 637        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 638        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 639        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 640        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 641        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 642        5,     6,     7,     8,     9,    10,    11,    12
 643 };
 644
 645 #if YYDEBUG
 646 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 647    YYRHS.  */
 648 static const yytype_uint8 yyprhs[] =
 649 {
 650        0,     0,     3,     8,    12,    14,    18,    21,    24,    28,
 651       29,    33,    35,    42,    43,    45,    46,    50,    52,    55,
 652       57,    59,    61,    63,    66,    67,    71,    73,    76,    78,
 653       80,    82,    84
 654 };
 655
 656 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 657 static const yytype_int8 yyrhs[] =
 658 {
 659       19,     0,    -1,    20,     9,    13,    22,    -1,    20,    13,
 660       21,    -1,    21,    -1,     3,    10,     8,    -1,     4,    10,
 661       -1,     5,    10,    -1,     6,    10,    10,    -1,    -1,    22,
 662       13,    23,    -1,    23,    -1,    25,    14,    24,     7,    24,
 663       28,    -1,    -1,    10,    -1,    -1,    25,    15,    26,    -1,
 664       26,    -1,    26,    27,    -1,    27,    -1,    16,    -1,    17,
 665       -1,    10,    -1,    12,    29,    -1,    -1,    29,    15,    30,
 666       -1,    30,    -1,    30,    31,    -1,    31,    -1,    10,    -1,
 667       11,    -1,     7,    -1,    14,    -1
 668 };
 669
 670 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 671 static const yytype_uint16 yyrline[] =
 672 {
 673        0,   244,   244,   254,   255,   258,   260,   262,   264,   276,
 674      279,   280,   283,   366,   369,   385,   388,   398,   405,   413,
 675      417,   424,   431,   453,   456,   459,   469,   477,   485,   488,
 676      520,   529,   536
 677 };
 678 #endif
 679
 680 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 681 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 682    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 683 static const char *const yytname[] =
 684 {
 685   "$end", "error", "$undefined", "kMASK", "kPREFIX", "kSUFFIX",
 686   "kSYNONYM", "kID", "kNUMBER", "kPERCPERC", "kBITFIELD", "kCHAR",
 687   "kSPACE", "'\\n'", "':'", "','", "'0'", "'1'", "$accept", "spec",
 688   "masks", "mask", "instrs", "instr", "bitfieldopt", "bytes", "byte",
 689   "bit", "optargs", "args", "arg", "argcomp", 0
 690 };
 691 #endif
 692
 693 # ifdef YYPRINT
 694 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
 695    token YYLEX-NUM.  */
 696 static const yytype_uint16 yytoknum[] =
 697 {
 698        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
 699      265,   266,   267,    10,    58,    44,    48,    49
 700 };
 701 # endif
 702
 703 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 704 static const yytype_uint8 yyr1[] =
 705 {
 706        0,    18,    19,    20,    20,    21,    21,    21,    21,    21,
 707       22,    22,    23,    23,    24,    24,    25,    25,    26,    26,
 708       27,    27,    27,    28,    28,    29,    29,    30,    30,    31,
 709       31,    31,    31
 710 };
 711
 712 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 713 static const yytype_uint8 yyr2[] =
 714 {
 715        0,     2,     4,     3,     1,     3,     2,     2,     3,     0,
 716        3,     1,     6,     0,     1,     0,     3,     1,     2,     1,
 717        1,     1,     1,     2,     0,     3,     1,     2,     1,     1,
 718        1,     1,     1
 719 };
 720
 721 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
 722    Performed when YYTABLE doesn't specify something else to do.  Zero
 723    means the default is an error.  */
 724 static const yytype_uint8 yydefact[] =
 725 {
 726        9,     0,     0,     0,     0,     0,     0,     4,     0,     6,
 727        7,     0,     1,     0,     9,     5,     8,    13,     3,    22,
 728       20,    21,     2,    11,     0,    17,    19,    13,    15,     0,
 729       18,    10,    14,     0,    16,    15,    24,     0,    12,    31,
 730       29,    30,    32,    23,    26,    28,     0,    27,    25
 731 };
 732
 733 /* YYDEFGOTO[NTERM-NUM].  */
 734 static const yytype_int8 yydefgoto[] =
 735 {
 736       -1,     5,     6,     7,    22,    23,    33,    24,    25,    26,
 737       38,    43,    44,    45
 738 };
 739
 740 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 741    STATE-NUM.  */
 742 #define YYPACT_NINF -35
 743 static const yytype_int8 yypact[] =
 744 {
 745       12,     9,    10,    11,    13,    22,    -2,   -35,    16,   -35,
 746      -35,    15,   -35,    14,    12,   -35,   -35,    -4,   -35,   -35,
 747      -35,   -35,    17,   -35,   -12,    -4,   -35,    -4,    18,    -4,
 748      -35,   -35,   -35,    19,    -4,    18,    20,    -6,   -35,   -35,
 749      -35,   -35,   -35,    21,    -6,   -35,    -6,   -35,    -6
 750 };
 751
 752 /* YYPGOTO[NTERM-NUM].  */
 753 static const yytype_int8 yypgoto[] =
 754 {
 755      -35,   -35,   -35,    23,   -35,     2,    -1,   -35,     4,   -25,
 756      -35,   -35,   -15,   -34
 757 };
 758
 759 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 760    positive, shift that token.  If negative, reduce the rule which
 761    number is the opposite.  If YYTABLE_NINF, syntax error.  */
 762 #define YYTABLE_NINF -1
 763 static const yytype_uint8 yytable[] =
 764 {
 765       30,    39,    28,    29,    40,    41,    19,    13,    42,    30,
 766       47,    14,    20,    21,    47,     1,     2,     3,     4,     8,
 767        9,    10,    12,    11,    15,    16,    35,    17,    32,    31,
 768       27,    48,    37,    34,    36,     0,    46,    18
 769 };
 770
 771 #define yypact_value_is_default(yystate) \
 772   ((yystate) == (-35))
 773
 774 #define yytable_value_is_error(yytable_value) \
 775   YYID (0)
 776
 777 static const yytype_int8 yycheck[] =
 778 {
 779       25,     7,    14,    15,    10,    11,    10,     9,    14,    34,
 780       44,    13,    16,    17,    48,     3,     4,     5,     6,    10,
 781       10,    10,     0,    10,     8,    10,     7,    13,    10,    27,
 782       13,    46,    12,    29,    35,    -1,    15,    14
 783 };
 784
 785 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
 786    symbol of state STATE-NUM.  */
 787 static const yytype_uint8 yystos[] =
 788 {
 789        0,     3,     4,     5,     6,    19,    20,    21,    10,    10,
 790       10,    10,     0,     9,    13,     8,    10,    13,    21,    10,
 791       16,    17,    22,    23,    25,    26,    27,    13,    14,    15,
 792       27,    23,    10,    24,    26,     7,    24,    12,    28,     7,
 793       10,    11,    14,    29,    30,    31,    15,    31,    30
 794 };
 795
 796 #define yyerrok         (yyerrstatus = 0)
 797 #define yyclearin       (yychar = YYEMPTY)
 798 #define YYEMPTY         (-2)
 799 #define YYEOF           0
 800
 801 #define YYACCEPT        goto yyacceptlab
 802 #define YYABORT         goto yyabortlab
 803 #define YYERROR         goto yyerrorlab
 804
 805
 806 /* Like YYERROR except do call yyerror.  This remains here temporarily
 807    to ease the transition to the new meaning of YYERROR, for GCC.
 808    Once GCC version 2 has supplanted version 1, this can go.  However,
 809    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
 810    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
 811    discussed.  */
 812
 813 #define YYFAIL          goto yyerrlab
 814 #if defined YYFAIL
 815   /* This is here to suppress warnings from the GCC cpp's
 816      -Wunused-macros.  Normally we don't worry about that warning, but
 817      some users do, and we want to make it easy for users to remove
 818      YYFAIL uses, which will produce warnings from Bison 2.5.  */
 819 #endif
 820
 821 #define YYRECOVERING()  (!!yyerrstatus)
 822
 823 #define YYBACKUP(Token, Value)                                  \
 824 do                                                              \
 825   if (yychar == YYEMPTY && yylen == 1)                          \
 826     {                                                           \
 827       yychar = (Token);                                         \
 828       yylval = (Value);                                         \
 829       YYPOPSTACK (1);                                           \
 830       goto yybackup;                                            \
 831     }                                                           \
 832   else                                                          \
 833     {                                                           \
 834       yyerror (YY_("syntax error: cannot back up")); \
 835       YYERROR;                                                  \
 836     }                                                           \
 837 while (YYID (0))
 838
 839
 840 #define YYTERROR        1
 841 #define YYERRCODE       256
 842
 843
 844 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
 845    If N is 0, then set CURRENT to the empty location which ends
 846    the previous symbol: RHS[0] (always defined).  */
 847
 848 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
 849 #ifndef YYLLOC_DEFAULT
 850 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
 851     do                                                                  \
 852       if (YYID (N))                                                    \
 853         {                                                               \
 854           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
 855           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
 856           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
 857           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
 858         }                                                               \
 859       else                                                              \
 860         {                                                               \
 861           (Current).first_line   = (Current).last_line   =              \
 862             YYRHSLOC (Rhs, 0).last_line;                                \
 863           (Current).first_column = (Current).last_column =              \
 864             YYRHSLOC (Rhs, 0).last_column;                              \
 865         }                                                               \
 866     while (YYID (0))
 867 #endif
 868
 869
 870 /* This macro is provided for backward compatibility. */
 871
 872 #ifndef YY_LOCATION_PRINT
 873 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
 874 #endif
 875
 876
 877 /* YYLEX -- calling `yylex' with the right arguments.  */
 878
 879 #ifdef YYLEX_PARAM
 880 # define YYLEX yylex (YYLEX_PARAM)
 881 #else
 882 # define YYLEX yylex ()
 883 #endif
 884
 885 /* Enable debugging if requested.  */
 886 #if YYDEBUG
 887
 888 # ifndef YYFPRINTF
 889 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 890 #  define YYFPRINTF fprintf
 891 # endif
 892
 893 # define YYDPRINTF(Args)                        \
 894 do {                                            \
 895   if (yydebug)                                  \
 896     YYFPRINTF Args;                             \
 897 } while (YYID (0))
 898
 899 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
 900 do {                                                                      \
 901   if (yydebug)                                                            \
 902     {                                                                     \
 903       YYFPRINTF (stderr, "%s ", Title);                                   \
 904       yy_symbol_print (stderr,                                            \
 905                   Type, Value); \
 906       YYFPRINTF (stderr, "\n");                                           \
 907     }                                                                     \
 908 } while (YYID (0))
 909
 910
 911 /*--------------------------------.
 912 | Print this symbol on YYOUTPUT.  |
 913 `--------------------------------*/
 914
 915 /*ARGSUSED*/
 916 #if (defined __STDC__ || defined __C99__FUNC__ \
 917      || defined __cplusplus || defined _MSC_VER)
 918 static void
 919 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
 920 #else
 921 static void
 922 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
 923     FILE *yyoutput;
 924     int yytype;
 925     YYSTYPE const * const yyvaluep;
 926 #endif
 927 {
 928   if (!yyvaluep)
 929     return;
 930 # ifdef YYPRINT
 931   if (yytype < YYNTOKENS)
 932     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 933 # else
 934   YYUSE (yyoutput);
 935 # endif
 936   switch (yytype)
 937     {
 938       default:
 939         break;
 940     }
 941 }
 942
 943
 944 /*--------------------------------.
 945 | Print this symbol on YYOUTPUT.  |
 946 `--------------------------------*/
 947
 948 #if (defined __STDC__ || defined __C99__FUNC__ \
 949      || defined __cplusplus || defined _MSC_VER)
 950 static void
 951 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
 952 #else
 953 static void
 954 yy_symbol_print (yyoutput, yytype, yyvaluep)
 955     FILE *yyoutput;
 956     int yytype;
 957     YYSTYPE const * const yyvaluep;
 958 #endif
 959 {
 960   if (yytype < YYNTOKENS)
 961     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
 962   else
 963     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 964
 965   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
 966   YYFPRINTF (yyoutput, ")");
 967 }
 968
 969 /*------------------------------------------------------------------.
 970 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
 971 | TOP (included).                                                   |
 972 `------------------------------------------------------------------*/
 973
 974 #if (defined __STDC__ || defined __C99__FUNC__ \
 975      || defined __cplusplus || defined _MSC_VER)
 976 static void
 977 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
 978 #else
 979 static void
 980 yy_stack_print (yybottom, yytop)
 981     yytype_int16 *yybottom;
 982     yytype_int16 *yytop;
 983 #endif
 984 {
 985   YYFPRINTF (stderr, "Stack now");
 986   for (; yybottom <= yytop; yybottom++)
 987     {
 988       int yybot = *yybottom;
 989       YYFPRINTF (stderr, " %d", yybot);
 990     }
 991   YYFPRINTF (stderr, "\n");
 992 }
 993
 994 # define YY_STACK_PRINT(Bottom, Top)                            \
 995 do {                                                            \
 996   if (yydebug)                                                  \
 997     yy_stack_print ((Bottom), (Top));                           \
 998 } while (YYID (0))
 999
1000
1001 /*------------------------------------------------.
1002 | Report that the YYRULE is going to be reduced.  |
1003 `------------------------------------------------*/
1004
1005 #if (defined __STDC__ || defined __C99__FUNC__ \
1006      || defined __cplusplus || defined _MSC_VER)
1007 static void
1008 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1009 #else
1010 static void
1011 yy_reduce_print (yyvsp, yyrule)
1012     YYSTYPE *yyvsp;
1013     int yyrule;
1014 #endif
1015 {
1016   int yynrhs = yyr2[yyrule];
1017   int yyi;
1018   unsigned long int yylno = yyrline[yyrule];
1019   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1020              yyrule - 1, yylno);
1021   /* The symbols being reduced.  */
1022   for (yyi = 0; yyi < yynrhs; yyi++)
1023     {
1024       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
1025       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1026                        &(yyvsp[(yyi + 1) - (yynrhs)])
1027                                        );
1028       YYFPRINTF (stderr, "\n");
1029     }
1030 }
1031
1032 # define YY_REDUCE_PRINT(Rule)          \
1033 do {                                    \
1034   if (yydebug)                          \
1035     yy_reduce_print (yyvsp, Rule); \
1036 } while (YYID (0))
1037
1038 /* Nonzero means print parse trace.  It is left uninitialized so that
1039    multiple parsers can coexist.  */
1040 int yydebug;
1041 #else /* !YYDEBUG */
1042 # define YYDPRINTF(Args)
1043 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1044 # define YY_STACK_PRINT(Bottom, Top)
1045 # define YY_REDUCE_PRINT(Rule)
1046 #endif /* !YYDEBUG */
1047
1048
1049 /* YYINITDEPTH -- initial size of the parser's stacks.  */
1050 #ifndef YYINITDEPTH
1051 # define YYINITDEPTH 200
1052 #endif
1053
1054 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1055    if the built-in stack extension method is used).
1056
1057    Do not make this value too large; the results are undefined if
1058    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1059    evaluated with infinite-precision integer arithmetic.  */
1060
1061 #ifndef YYMAXDEPTH
1062 # define YYMAXDEPTH 10000
1063 #endif
1064
1065
1066 #if YYERROR_VERBOSE
1067
1068 # ifndef yystrlen
1069 #  if defined __GLIBC__ && defined _STRING_H
1070 #   define yystrlen strlen
1071 #  else
1072 /* Return the length of YYSTR.  */
1073 #if (defined __STDC__ || defined __C99__FUNC__ \
1074      || defined __cplusplus || defined _MSC_VER)
1075 static YYSIZE_T
1076 yystrlen (const char *yystr)
1077 #else
1078 static YYSIZE_T
1079 yystrlen (yystr)
1080     const char *yystr;
1081 #endif
1082 {
1083   YYSIZE_T yylen;
1084   for (yylen = 0; yystr[yylen]; yylen++)
1085     continue;
1086   return yylen;
1087 }
1088 #  endif
1089 # endif
1090
1091 # ifndef yystpcpy
1092 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1093 #   define yystpcpy stpcpy
1094 #  else
1095 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1096    YYDEST.  */
1097 #if (defined __STDC__ || defined __C99__FUNC__ \
1098      || defined __cplusplus || defined _MSC_VER)
1099 static char *
1100 yystpcpy (char *yydest, const char *yysrc)
1101 #else
1102 static char *
1103 yystpcpy (yydest, yysrc)
1104     char *yydest;
1105     const char *yysrc;
1106 #endif
1107 {
1108   char *yyd = yydest;
1109   const char *yys = yysrc;
1110
1111   while ((*yyd++ = *yys++) != '\0')
1112     continue;
1113
1114   return yyd - 1;
1115 }
1116 #  endif
1117 # endif
1118
1119 # ifndef yytnamerr
1120 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1121    quotes and backslashes, so that it's suitable for yyerror.  The
1122    heuristic is that double-quoting is unnecessary unless the string
1123    contains an apostrophe, a comma, or backslash (other than
1124    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1125    null, do not copy; instead, return the length of what the result
1126    would have been.  */
1127 static YYSIZE_T
1128 yytnamerr (char *yyres, const char *yystr)
1129 {
1130   if (*yystr == '"')
1131     {
1132       YYSIZE_T yyn = 0;
1133       char const *yyp = yystr;
1134
1135       for (;;)
1136         switch (*++yyp)
1137           {
1138           case '\'':
1139           case ',':
1140             goto do_not_strip_quotes;
1141
1142           case '\\':
1143             if (*++yyp != '\\')
1144               goto do_not_strip_quotes;
1145             /* Fall through.  */
1146           default:
1147             if (yyres)
1148               yyres[yyn] = *yyp;
1149             yyn++;
1150             break;
1151
1152           case '"':
1153             if (yyres)
1154               yyres[yyn] = '\0';
1155             return yyn;
1156           }
1157     do_not_strip_quotes: ;
1158     }
1159
1160   if (! yyres)
1161     return yystrlen (yystr);
1162
1163   return yystpcpy (yyres, yystr) - yyres;
1164 }
1165 # endif
1166
1167 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1168    about the unexpected token YYTOKEN for the state stack whose top is
1169    YYSSP.
1170
1171    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
1172    not large enough to hold the message.  In that case, also set
1173    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
1174    required number of bytes is too large to store.  */
1175 static int
1176 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1177                 yytype_int16 *yyssp, int yytoken)
1178 {
1179   YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
1180   YYSIZE_T yysize = yysize0;
1181   YYSIZE_T yysize1;
1182   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1183   /* Internationalized format string. */
1184   const char *yyformat = 0;
1185   /* Arguments of yyformat. */
1186   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1187   /* Number of reported tokens (one for the "unexpected", one per
1188      "expected"). */
1189   int yycount = 0;
1190
1191   /* There are many possibilities here to consider:
1192      - Assume YYFAIL is not used.  It's too flawed to consider.  See
1193        <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1194        for details.  YYERROR is fine as it does not invoke this
1195        function.
1196      - If this state is a consistent state with a default action, then
1197        the only way this function was invoked is if the default action
1198        is an error action.  In that case, don't check for expected
1199        tokens because there are none.
1200      - The only way there can be no lookahead present (in yychar) is if
1201        this state is a consistent state with a default action.  Thus,
1202        detecting the absence of a lookahead is sufficient to determine
1203        that there is no unexpected or expected token to report.  In that
1204        case, just report a simple "syntax error".
1205      - Don't assume there isn't a lookahead just because this state is a
1206        consistent state with a default action.  There might have been a
1207        previous inconsistent state, consistent state with a non-default
1208        action, or user semantic action that manipulated yychar.
1209      - Of course, the expected token list depends on states to have
1210        correct lookahead information, and it depends on the parser not
1211        to perform extra reductions after fetching a lookahead from the
1212        scanner and before detecting a syntax error.  Thus, state merging
1213        (from LALR or IELR) and default reductions corrupt the expected
1214        token list.  However, the list is correct for canonical LR with
1215        one exception: it will still contain any token that will not be
1216        accepted due to an error action in a later state.
1217   */
1218   if (yytoken != YYEMPTY)
1219     {
1220       int yyn = yypact[*yyssp];
1221       yyarg[yycount++] = yytname[yytoken];
1222       if (!yypact_value_is_default (yyn))
1223         {
1224           /* Start YYX at -YYN if negative to avoid negative indexes in
1225              YYCHECK.  In other words, skip the first -YYN actions for
1226              this state because they are default actions.  */
1227           int yyxbegin = yyn < 0 ? -yyn : 0;
1228           /* Stay within bounds of both yycheck and yytname.  */
1229           int yychecklim = YYLAST - yyn + 1;
1230           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1231           int yyx;
1232
1233           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1234             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1235                 && !yytable_value_is_error (yytable[yyx + yyn]))
1236               {
1237                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1238                   {
1239                     yycount = 1;
1240                     yysize = yysize0;
1241                     break;
1242                   }
1243                 yyarg[yycount++] = yytname[yyx];
1244                 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1245                 if (! (yysize <= yysize1
1246                        && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1247                   return 2;
1248                 yysize = yysize1;
1249               }
1250         }
1251     }
1252
1253   switch (yycount)
1254     {
1255 # define YYCASE_(N, S)                      \
1256       case N:                               \
1257         yyformat = S;                       \
1258       break
1259       YYCASE_(0, YY_("syntax error"));
1260       YYCASE_(1, YY_("syntax error, unexpected %s"));
1261       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1262       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1263       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1264       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1265 # undef YYCASE_
1266     }
1267
1268   yysize1 = yysize + yystrlen (yyformat);
1269   if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1270     return 2;
1271   yysize = yysize1;
1272
1273   if (*yymsg_alloc < yysize)
1274     {
1275       *yymsg_alloc = 2 * yysize;
1276       if (! (yysize <= *yymsg_alloc
1277              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1278         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1279       return 1;
1280     }
1281
1282   /* Avoid sprintf, as that infringes on the user's name space.
1283      Don't have undefined behavior even if the translation
1284      produced a string with the wrong number of "%s"s.  */
1285   {
1286     char *yyp = *yymsg;
1287     int yyi = 0;
1288     while ((*yyp = *yyformat) != '\0')
1289       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1290         {
1291           yyp += yytnamerr (yyp, yyarg[yyi++]);
1292           yyformat += 2;
1293         }
1294       else
1295         {
1296           yyp++;
1297           yyformat++;
1298         }
1299   }
1300   return 0;
1301 }
1302 #endif /* YYERROR_VERBOSE */
1303
1304 /*-----------------------------------------------.
1305 | Release the memory associated to this symbol.  |
1306 `-----------------------------------------------*/
1307
1308 /*ARGSUSED*/
1309 #if (defined __STDC__ || defined __C99__FUNC__ \
1310      || defined __cplusplus || defined _MSC_VER)
1311 static void
1312 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1313 #else
1314 static void
1315 yydestruct (yymsg, yytype, yyvaluep)
1316     const char *yymsg;
1317     int yytype;
1318     YYSTYPE *yyvaluep;
1319 #endif
1320 {
1321   YYUSE (yyvaluep);
1322
1323   if (!yymsg)
1324     yymsg = "Deleting";
1325   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1326
1327   switch (yytype)
1328     {
1329
1330       default:
1331         break;
1332     }
1333 }
1334
1335
1336 /* Prevent warnings from -Wmissing-prototypes.  */
1337 #ifdef YYPARSE_PARAM
1338 #if defined __STDC__ || defined __cplusplus
1339 int yyparse (void *YYPARSE_PARAM);
1340 #else
1341 int yyparse ();
1342 #endif
1343 #else /* ! YYPARSE_PARAM */
1344 #if defined __STDC__ || defined __cplusplus
1345 int yyparse (void);
1346 #else
1347 int yyparse ();
1348 #endif
1349 #endif /* ! YYPARSE_PARAM */
1350
1351
1352 /* The lookahead symbol.  */
1353 int yychar;
1354
1355 /* The semantic value of the lookahead symbol.  */
1356 YYSTYPE yylval;
1357
1358 /* Number of syntax errors so far.  */
1359 int yynerrs;
1360
1361
1362 /*----------.
1363 | yyparse.  |
1364 `----------*/
1365
1366 #ifdef YYPARSE_PARAM
1367 #if (defined __STDC__ || defined __C99__FUNC__ \
1368      || defined __cplusplus || defined _MSC_VER)
1369 int
1370 yyparse (void *YYPARSE_PARAM)
1371 #else
1372 int
1373 yyparse (YYPARSE_PARAM)
1374     void *YYPARSE_PARAM;
1375 #endif
1376 #else /* ! YYPARSE_PARAM */
1377 #if (defined __STDC__ || defined __C99__FUNC__ \
1378      || defined __cplusplus || defined _MSC_VER)
1379 int
1380 yyparse (void)
1381 #else
1382 int
1383 yyparse ()
1384
1385 #endif
1386 #endif
1387 {
1388     int yystate;
1389     /* Number of tokens to shift before error messages enabled.  */
1390     int yyerrstatus;
1391
1392     /* The stacks and their tools:
1393        `yyss': related to states.
1394        `yyvs': related to semantic values.
1395
1396        Refer to the stacks thru separate pointers, to allow yyoverflow
1397        to reallocate them elsewhere.  */
1398
1399     /* The state stack.  */
1400     yytype_int16 yyssa[YYINITDEPTH];
1401     yytype_int16 *yyss;
1402     yytype_int16 *yyssp;
1403
1404     /* The semantic value stack.  */
1405     YYSTYPE yyvsa[YYINITDEPTH];
1406     YYSTYPE *yyvs;
1407     YYSTYPE *yyvsp;
1408
1409     YYSIZE_T yystacksize;
1410
1411   int yyn;
1412   int yyresult;
1413   /* Lookahead token as an internal (translated) token number.  */
1414   int yytoken;
1415   /* The variables used to return semantic value and location from the
1416      action routines.  */
1417   YYSTYPE yyval;
1418
1419 #if YYERROR_VERBOSE
1420   /* Buffer for error messages, and its allocated size.  */
1421   char yymsgbuf[128];
1422   char *yymsg = yymsgbuf;
1423   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1424 #endif
1425
1426 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1427
1428   /* The number of symbols on the RHS of the reduced rule.
1429      Keep to zero when no symbol should be popped.  */
1430   int yylen = 0;
1431
1432   yytoken = 0;
1433   yyss = yyssa;
1434   yyvs = yyvsa;
1435   yystacksize = YYINITDEPTH;
1436
1437   YYDPRINTF ((stderr, "Starting parse\n"));
1438
1439   yystate = 0;
1440   yyerrstatus = 0;
1441   yynerrs = 0;
1442   yychar = YYEMPTY; /* Cause a token to be read.  */
1443
1444   /* Initialize stack pointers.
1445      Waste one element of value and location stack
1446      so that they stay on the same level as the state stack.
1447      The wasted elements are never initialized.  */
1448   yyssp = yyss;
1449   yyvsp = yyvs;
1450
1451   goto yysetstate;
1452
1453 /*------------------------------------------------------------.
1454 | yynewstate -- Push a new state, which is found in yystate.  |
1455 `------------------------------------------------------------*/
1456  yynewstate:
1457   /* In all cases, when you get here, the value and location stacks
1458      have just been pushed.  So pushing a state here evens the stacks.  */
1459   yyssp++;
1460
1461  yysetstate:
1462   *yyssp = yystate;
1463
1464   if (yyss + yystacksize - 1 <= yyssp)
1465     {
1466       /* Get the current used size of the three stacks, in elements.  */
1467       YYSIZE_T yysize = yyssp - yyss + 1;
1468
1469 #ifdef yyoverflow
1470       {
1471         /* Give user a chance to reallocate the stack.  Use copies of
1472            these so that the &'s don't force the real ones into
1473            memory.  */
1474         YYSTYPE *yyvs1 = yyvs;
1475         yytype_int16 *yyss1 = yyss;
1476
1477         /* Each stack pointer address is followed by the size of the
1478            data in use in that stack, in bytes.  This used to be a
1479            conditional around just the two extra args, but that might
1480            be undefined if yyoverflow is a macro.  */
1481         yyoverflow (YY_("memory exhausted"),
1482                     &yyss1, yysize * sizeof (*yyssp),
1483                     &yyvs1, yysize * sizeof (*yyvsp),
1484                     &yystacksize);
1485
1486         yyss = yyss1;
1487         yyvs = yyvs1;
1488       }
1489 #else /* no yyoverflow */
1490 # ifndef YYSTACK_RELOCATE
1491       goto yyexhaustedlab;
1492 # else
1493       /* Extend the stack our own way.  */
1494       if (YYMAXDEPTH <= yystacksize)
1495         goto yyexhaustedlab;
1496       yystacksize *= 2;
1497       if (YYMAXDEPTH < yystacksize)
1498         yystacksize = YYMAXDEPTH;
1499
1500       {
1501         yytype_int16 *yyss1 = yyss;
1502         union yyalloc *yyptr =
1503           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1504         if (! yyptr)
1505           goto yyexhaustedlab;
1506         YYSTACK_RELOCATE (yyss_alloc, yyss);
1507         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1508 #  undef YYSTACK_RELOCATE
1509         if (yyss1 != yyssa)
1510           YYSTACK_FREE (yyss1);
1511       }
1512 # endif
1513 #endif /* no yyoverflow */
1514
1515       yyssp = yyss + yysize - 1;
1516       yyvsp = yyvs + yysize - 1;
1517
1518       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1519                   (unsigned long int) yystacksize));
1520
1521       if (yyss + yystacksize - 1 <= yyssp)
1522         YYABORT;
1523     }
1524
1525   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1526
1527   if (yystate == YYFINAL)
1528     YYACCEPT;
1529
1530   goto yybackup;
1531
1532 /*-----------.
1533 | yybackup.  |
1534 `-----------*/
1535 yybackup:
1536
1537   /* Do appropriate processing given the current state.  Read a
1538      lookahead token if we need one and don't already have one.  */
1539
1540   /* First try to decide what to do without reference to lookahead token.  */
1541   yyn = yypact[yystate];
1542   if (yypact_value_is_default (yyn))
1543     goto yydefault;
1544
1545   /* Not known => get a lookahead token if don't already have one.  */
1546
1547   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1548   if (yychar == YYEMPTY)
1549     {
1550       YYDPRINTF ((stderr, "Reading a token: "));
1551       yychar = YYLEX;
1552     }
1553
1554   if (yychar <= YYEOF)
1555     {
1556       yychar = yytoken = YYEOF;
1557       YYDPRINTF ((stderr, "Now at end of input.\n"));
1558     }
1559   else
1560     {
1561       yytoken = YYTRANSLATE (yychar);
1562       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1563     }
1564
1565   /* If the proper action on seeing token YYTOKEN is to reduce or to
1566      detect an error, take that action.  */
1567   yyn += yytoken;
1568   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1569     goto yydefault;
1570   yyn = yytable[yyn];
1571   if (yyn <= 0)
1572     {
1573       if (yytable_value_is_error (yyn))
1574         goto yyerrlab;
1575       yyn = -yyn;
1576       goto yyreduce;
1577     }
1578
1579   /* Count tokens shifted since error; after three, turn off error
1580      status.  */
1581   if (yyerrstatus)
1582     yyerrstatus--;
1583
1584   /* Shift the lookahead token.  */
1585   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1586
1587   /* Discard the shifted token.  */
1588   yychar = YYEMPTY;
1589
1590   yystate = yyn;
1591   *++yyvsp = yylval;
1592
1593   goto yynewstate;
1594
1595
1596 /*-----------------------------------------------------------.
1597 | yydefault -- do the default action for the current state.  |
1598 `-----------------------------------------------------------*/
1599 yydefault:
1600   yyn = yydefact[yystate];
1601   if (yyn == 0)
1602     goto yyerrlab;
1603   goto yyreduce;
1604
1605
1606 /*-----------------------------.
1607 | yyreduce -- Do a reduction.  |
1608 `-----------------------------*/
1609 yyreduce:
1610   /* yyn is the number of a rule to reduce with.  */
1611   yylen = yyr2[yyn];
1612
1613   /* If YYLEN is nonzero, implement the default value of the action:
1614      `$$ = $1'.
1615
1616      Otherwise, the following line sets YYVAL to garbage.
1617      This behavior is undocumented and Bison
1618      users should not rely upon it.  Assigning to YYVAL
1619      unconditionally makes the parser a bit smaller, and it avoids a
1620      GCC warning that YYVAL may be used uninitialized.  */
1621   yyval = yyvsp[1-yylen];
1622
1623
1624   YY_REDUCE_PRINT (yyn);
1625   switch (yyn)
1626     {
1627         case 2:
1628
1629 /* Line 1806 of yacc.c  */
1630 #line 245 "i386_parse.y"
1631     {
1632                       if (error_message_count != 0)
1633                         error (EXIT_FAILURE, 0,
1634                                "terminated due to previous error");
1635
1636                       instrtable_out ();
1637                     }
1638     break;
1639
1640   case 5:
1641
1642 /* Line 1806 of yacc.c  */
1643 #line 259 "i386_parse.y"
1644     { new_bitfield ((yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].num)); }
1645     break;
1646
1647   case 6:
1648
1649 /* Line 1806 of yacc.c  */
1650 #line 261 "i386_parse.y"
1651     { new_bitfield ((yyvsp[(2) - (2)].str), -1); }
1652     break;
1653
1654   case 7:
1655
1656 /* Line 1806 of yacc.c  */
1657 #line 263 "i386_parse.y"
1658     { new_bitfield ((yyvsp[(2) - (2)].str), -2); }
1659     break;
1660
1661   case 8:
1662
1663 /* Line 1806 of yacc.c  */
1664 #line 265 "i386_parse.y"
1665     {
1666                       struct synonym *newp = xmalloc (sizeof (*newp));
1667                       newp->from = (yyvsp[(2) - (3)].str);
1668                       newp->to = (yyvsp[(3) - (3)].str);
1669                       if (tfind (newp, &synonyms, compare_syn) != NULL)
1670                         error (0, 0,
1671                                "%d: duplicate definition for synonym '%s'",
1672                                i386_lineno, (yyvsp[(2) - (3)].str));
1673                       else if (tsearch ( newp, &synonyms, compare_syn) == NULL)
1674                         error (EXIT_FAILURE, 0, "tsearch");
1675                     }
1676     break;
1677
1678   case 12:
1679
1680 /* Line 1806 of yacc.c  */
1681 #line 284 "i386_parse.y"
1682     {
1683                       if ((yyvsp[(3) - (6)].field) != NULL && strcmp ((yyvsp[(3) - (6)].field)->name, "RE") != 0
1684                           && strcmp ((yyvsp[(3) - (6)].field)->name, "R") != 0)
1685                         {
1686                           error (0, 0, "%d: only 'R' and 'RE' prefix allowed",
1687                                  i386_lineno - 1);
1688                         }
1689                       if (check_duplicates ((yyvsp[(1) - (6)].bit)) == 0
1690                           && check_argsdef ((yyvsp[(1) - (6)].bit), (yyvsp[(6) - (6)].arg)) == 0
1691                           && check_bitsused ((yyvsp[(1) - (6)].bit), (yyvsp[(5) - (6)].field), (yyvsp[(6) - (6)].arg)) == 0)
1692                         {
1693                           struct instruction *newp = xcalloc (sizeof (*newp),
1694                                                               1);
1695                           if ((yyvsp[(3) - (6)].field) != NULL)
1696                             {
1697                               if (strcmp ((yyvsp[(3) - (6)].field)->name, "RE") == 0)
1698                                 newp->repe = 1;
1699                               else if (strcmp ((yyvsp[(3) - (6)].field)->name, "R") == 0)
1700                                 newp->rep = 1;
1701                             }
1702
1703                           newp->bytes = (yyvsp[(1) - (6)].bit);
1704                           newp->mnemonic = (yyvsp[(4) - (6)].str);
1705                           if (newp->mnemonic != (void *) -1l
1706                               && tfind ((yyvsp[(4) - (6)].str), &mnemonics,
1707                                         (comparison_fn_t) strcmp) == NULL)
1708                             {
1709                               if (tsearch ((yyvsp[(4) - (6)].str), &mnemonics,
1710                                            (comparison_fn_t) strcmp) == NULL)
1711                                 error (EXIT_FAILURE, errno, "tsearch");
1712                               ++nmnemonics;
1713                             }
1714
1715                           if ((yyvsp[(5) - (6)].field) != NULL)
1716                             {
1717                               if (strcmp ((yyvsp[(5) - (6)].field)->name, "w") == 0)
1718                                 newp->suffix = suffix_w;
1719                               else if (strcmp ((yyvsp[(5) - (6)].field)->name, "w0") == 0)
1720                                 newp->suffix = suffix_w0;
1721                               else if (strcmp ((yyvsp[(5) - (6)].field)->name, "tttn") == 0)
1722                                 newp->suffix = suffix_tttn;
1723                               else if (strcmp ((yyvsp[(5) - (6)].field)->name, "w1") == 0)
1724                                 newp->suffix = suffix_w1;
1725                               else if (strcmp ((yyvsp[(5) - (6)].field)->name, "W") == 0)
1726                                 newp->suffix = suffix_W;
1727                               else if (strcmp ((yyvsp[(5) - (6)].field)->name, "W1") == 0)
1728                                 newp->suffix = suffix_W1;
1729                               else if (strcmp ((yyvsp[(5) - (6)].field)->name, "D") == 0)
1730                                 newp->suffix = suffix_D;
1731                               else
1732                                 error (EXIT_FAILURE, 0,
1733                                        "%s: %d: unknown suffix '%s'",
1734                                        infname, i386_lineno - 1, (yyvsp[(5) - (6)].field)->name);
1735
1736                               struct suffix search = { .name = (yyvsp[(5) - (6)].field)->name };
1737                               if (tfind (&search, &suffixes, compare_suf)
1738                                   == NULL)
1739                                 {
1740                                   struct suffix *ns = xmalloc (sizeof (*ns));
1741                                   ns->name = (yyvsp[(5) - (6)].field)->name;
1742                                   ns->idx = ++nsuffixes;
1743                                   if (tsearch (ns, &suffixes, compare_suf)
1744                                       == NULL)
1745                                     error (EXIT_FAILURE, errno, "tsearch");
1746                                 }
1747                             }
1748
1749                           struct argument *args = (yyvsp[(6) - (6)].arg);
1750                           int n = 0;
1751                           while (args != NULL)
1752                             {
1753                               fillin_arg ((yyvsp[(1) - (6)].bit), args->name, newp, n);
1754
1755                               args = args->next;
1756                               ++n;
1757                             }
1758
1759                           newp->next = instructions;
1760                           instructions = newp;
1761                           ++ninstructions;
1762                         }
1763                     }
1764     break;
1765
1766   case 14:
1767
1768 /* Line 1806 of yacc.c  */
1769 #line 370 "i386_parse.y"
1770     {
1771                       struct known_bitfield search;
1772                       search.name = (yyvsp[(1) - (1)].str);
1773                       struct known_bitfield **res;
1774                       res = tfind (&search, &bitfields, bitfield_compare);
1775                       if (res == NULL)
1776                         {
1777                           error (0, 0, "%d: unknown bitfield '%s'",
1778                                  i386_lineno, search.name);
1779                           (yyval.field) = NULL;
1780                         }
1781                       else
1782                         (yyval.field) = *res;
1783                     }
1784     break;
1785
1786   case 15:
1787
1788 /* Line 1806 of yacc.c  */
1789 #line 385 "i386_parse.y"
1790     { (yyval.field) = NULL; }
1791     break;
1792
1793   case 16:
1794
1795 /* Line 1806 of yacc.c  */
1796 #line 389 "i386_parse.y"
1797     {
1798                       check_bits ((yyvsp[(3) - (3)].bit));
1799
1800                       struct bitvalue *runp = (yyvsp[(1) - (3)].bit);
1801                       while (runp->next != NULL)
1802                         runp = runp->next;
1803                       runp->next = (yyvsp[(3) - (3)].bit);
1804                       (yyval.bit) = (yyvsp[(1) - (3)].bit);
1805                     }
1806     break;
1807
1808   case 17:
1809
1810 /* Line 1806 of yacc.c  */
1811 #line 399 "i386_parse.y"
1812     {
1813                       check_bits ((yyvsp[(1) - (1)].bit));
1814                       (yyval.bit) = (yyvsp[(1) - (1)].bit);
1815                     }
1816     break;
1817
1818   case 18:
1819
1820 /* Line 1806 of yacc.c  */
1821 #line 406 "i386_parse.y"
1822     {
1823                       struct bitvalue *runp = (yyvsp[(1) - (2)].bit);
1824                       while (runp->next != NULL)
1825                         runp = runp->next;
1826                       runp->next = (yyvsp[(2) - (2)].bit);
1827                       (yyval.bit) = (yyvsp[(1) - (2)].bit);
1828                     }
1829     break;
1830
1831   case 19:
1832
1833 /* Line 1806 of yacc.c  */
1834 #line 414 "i386_parse.y"
1835     { (yyval.bit) = (yyvsp[(1) - (1)].bit); }
1836     break;
1837
1838   case 20:
1839
1840 /* Line 1806 of yacc.c  */
1841 #line 418 "i386_parse.y"
1842     {
1843                       (yyval.bit) = xmalloc (sizeof (struct bitvalue));
1844                       (yyval.bit)->type = zeroone;
1845                       (yyval.bit)->value = 0;
1846                       (yyval.bit)->next = NULL;
1847                     }
1848     break;
1849
1850   case 21:
1851
1852 /* Line 1806 of yacc.c  */
1853 #line 425 "i386_parse.y"
1854     {
1855                       (yyval.bit) = xmalloc (sizeof (struct bitvalue));
1856                       (yyval.bit)->type = zeroone;
1857                       (yyval.bit)->value = 1;
1858                       (yyval.bit)->next = NULL;
1859                     }
1860     break;
1861
1862   case 22:
1863
1864 /* Line 1806 of yacc.c  */
1865 #line 432 "i386_parse.y"
1866     {
1867                       (yyval.bit) = xmalloc (sizeof (struct bitvalue));
1868                       struct known_bitfield search;
1869                       search.name = (yyvsp[(1) - (1)].str);
1870                       struct known_bitfield **res;
1871                       res = tfind (&search, &bitfields, bitfield_compare);
1872                       if (res == NULL)
1873                         {
1874                           error (0, 0, "%d: unknown bitfield '%s'",
1875                                  i386_lineno, search.name);
1876                           (yyval.bit)->type = failure;
1877                         }
1878                       else
1879                         {
1880                           (yyval.bit)->type = field;
1881                           (yyval.bit)->field = *res;
1882                         }
1883                       (yyval.bit)->next = NULL;
1884                     }
1885     break;
1886
1887   case 23:
1888
1889 /* Line 1806 of yacc.c  */
1890 #line 454 "i386_parse.y"
1891     { (yyval.arg) = (yyvsp[(2) - (2)].arg); }
1892     break;
1893
1894   case 24:
1895
1896 /* Line 1806 of yacc.c  */
1897 #line 456 "i386_parse.y"
1898     { (yyval.arg) = NULL; }
1899     break;
1900
1901   case 25:
1902
1903 /* Line 1806 of yacc.c  */
1904 #line 460 "i386_parse.y"
1905     {
1906                       struct argument *runp = (yyvsp[(1) - (3)].arg);
1907                       while (runp->next != NULL)
1908                         runp = runp->next;
1909                       runp->next = xmalloc (sizeof (struct argument));
1910                       runp->next->name = combine ((yyvsp[(3) - (3)].name));
1911                       runp->next->next = NULL;
1912                       (yyval.arg) = (yyvsp[(1) - (3)].arg);
1913                     }
1914     break;
1915
1916   case 26:
1917
1918 /* Line 1806 of yacc.c  */
1919 #line 470 "i386_parse.y"
1920     {
1921                       (yyval.arg) = xmalloc (sizeof (struct argument));
1922                       (yyval.arg)->name = combine ((yyvsp[(1) - (1)].name));
1923                       (yyval.arg)->next = NULL;
1924                     }
1925     break;
1926
1927   case 27:
1928
1929 /* Line 1806 of yacc.c  */
1930 #line 478 "i386_parse.y"
1931     {
1932                       struct argname *runp = (yyvsp[(1) - (2)].name);
1933                       while (runp->next != NULL)
1934                         runp = runp->next;
1935                       runp->next = (yyvsp[(2) - (2)].name);
1936                       (yyval.name) = (yyvsp[(1) - (2)].name);
1937                     }
1938     break;
1939
1940   case 28:
1941
1942 /* Line 1806 of yacc.c  */
1943 #line 486 "i386_parse.y"
1944     { (yyval.name) = (yyvsp[(1) - (1)].name); }
1945     break;
1946
1947   case 29:
1948
1949 /* Line 1806 of yacc.c  */
1950 #line 489 "i386_parse.y"
1951     {
1952                       (yyval.name) = xmalloc (sizeof (struct argname));
1953                       (yyval.name)->type = nfield;
1954                       (yyval.name)->next = NULL;
1955
1956                       struct known_bitfield search;
1957                       search.name = (yyvsp[(1) - (1)].str);
1958                       struct known_bitfield **res;
1959                       res = tfind (&search, &bitfields, bitfield_compare);
1960                       if (res == NULL)
1961                         {
1962                           if (strcmp ((yyvsp[(1) - (1)].str), "ax") == 0)
1963                             (yyval.name)->field = &ax_reg;
1964                           else if (strcmp ((yyvsp[(1) - (1)].str), "dx") == 0)
1965                             (yyval.name)->field = &dx_reg;
1966                           else if (strcmp ((yyvsp[(1) - (1)].str), "es_di") == 0)
1967                             (yyval.name)->field = &di_reg;
1968                           else if (strcmp ((yyvsp[(1) - (1)].str), "ds_si") == 0)
1969                             (yyval.name)->field = &si_reg;
1970                           else if (strcmp ((yyvsp[(1) - (1)].str), "ds_bx") == 0)
1971                             (yyval.name)->field = &bx_reg;
1972                           else
1973                             {
1974                               error (0, 0, "%d: unknown bitfield '%s'",
1975                                      i386_lineno, search.name);
1976                               (yyval.name)->field = NULL;
1977                             }
1978                         }
1979                       else
1980                         (yyval.name)->field = *res;
1981                     }
1982     break;
1983
1984   case 30:
1985
1986 /* Line 1806 of yacc.c  */
1987 #line 521 "i386_parse.y"
1988     {
1989                       (yyval.name) = xmalloc (sizeof (struct argname));
1990                       (yyval.name)->type = string;
1991                       (yyval.name)->next = NULL;
1992                       (yyval.name)->str = xmalloc (2);
1993                       (yyval.name)->str[0] = (yyvsp[(1) - (1)].ch);
1994                       (yyval.name)->str[1] = '\0';
1995                     }
1996     break;
1997
1998   case 31:
1999
2000 /* Line 1806 of yacc.c  */
2001 #line 530 "i386_parse.y"
2002     {
2003                       (yyval.name) = xmalloc (sizeof (struct argname));
2004                       (yyval.name)->type = string;
2005                       (yyval.name)->next = NULL;
2006                       (yyval.name)->str = (yyvsp[(1) - (1)].str);
2007                     }
2008     break;
2009
2010   case 32:
2011
2012 /* Line 1806 of yacc.c  */
2013 #line 537 "i386_parse.y"
2014     {
2015                       (yyval.name) = xmalloc (sizeof (struct argname));
2016                       (yyval.name)->type = string;
2017                       (yyval.name)->next = NULL;
2018                       (yyval.name)->str = xmalloc (2);
2019                       (yyval.name)->str[0] = ':';
2020                       (yyval.name)->str[1] = '\0';
2021                     }
2022     break;
2023
2024
2025
2026 /* Line 1806 of yacc.c  */
2027 #line 2028 "i386_parse.c"
2028       default: break;
2029     }
2030   /* User semantic actions sometimes alter yychar, and that requires
2031      that yytoken be updated with the new translation.  We take the
2032      approach of translating immediately before every use of yytoken.
2033      One alternative is translating here after every semantic action,
2034      but that translation would be missed if the semantic action invokes
2035      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2036      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
2037      incorrect destructor might then be invoked immediately.  In the
2038      case of YYERROR or YYBACKUP, subsequent parser actions might lead
2039      to an incorrect destructor call or verbose syntax error message
2040      before the lookahead is translated.  */
2041   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2042
2043   YYPOPSTACK (yylen);
2044   yylen = 0;
2045   YY_STACK_PRINT (yyss, yyssp);
2046
2047   *++yyvsp = yyval;
2048
2049   /* Now `shift' the result of the reduction.  Determine what state
2050      that goes to, based on the state we popped back to and the rule
2051      number reduced by.  */
2052
2053   yyn = yyr1[yyn];
2054
2055   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2056   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2057     yystate = yytable[yystate];
2058   else
2059     yystate = yydefgoto[yyn - YYNTOKENS];
2060
2061   goto yynewstate;
2062
2063
2064 /*------------------------------------.
2065 | yyerrlab -- here on detecting error |
2066 `------------------------------------*/
2067 yyerrlab:
2068   /* Make sure we have latest lookahead translation.  See comments at
2069      user semantic actions for why this is necessary.  */
2070   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
2071
2072   /* If not already recovering from an error, report this error.  */
2073   if (!yyerrstatus)
2074     {
2075       ++yynerrs;
2076 #if ! YYERROR_VERBOSE
2077       yyerror (YY_("syntax error"));
2078 #else
2079 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
2080                                         yyssp, yytoken)
2081       {
2082         char const *yymsgp = YY_("syntax error");
2083         int yysyntax_error_status;
2084         yysyntax_error_status = YYSYNTAX_ERROR;
2085         if (yysyntax_error_status == 0)
2086           yymsgp = yymsg;
2087         else if (yysyntax_error_status == 1)
2088           {
2089             if (yymsg != yymsgbuf)
2090               YYSTACK_FREE (yymsg);
2091             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
2092             if (!yymsg)
2093               {
2094                 yymsg = yymsgbuf;
2095                 yymsg_alloc = sizeof yymsgbuf;
2096                 yysyntax_error_status = 2;
2097               }
2098             else
2099               {
2100                 yysyntax_error_status = YYSYNTAX_ERROR;
2101                 yymsgp = yymsg;
2102               }
2103           }
2104         yyerror (yymsgp);
2105         if (yysyntax_error_status == 2)
2106           goto yyexhaustedlab;
2107       }
2108 # undef YYSYNTAX_ERROR
2109 #endif
2110     }
2111
2112
2113
2114   if (yyerrstatus == 3)
2115     {
2116       /* If just tried and failed to reuse lookahead token after an
2117          error, discard it.  */
2118
2119       if (yychar <= YYEOF)
2120         {
2121           /* Return failure if at end of input.  */
2122           if (yychar == YYEOF)
2123             YYABORT;
2124         }
2125       else
2126         {
2127           yydestruct ("Error: discarding",
2128                       yytoken, &yylval);
2129           yychar = YYEMPTY;
2130         }
2131     }
2132
2133   /* Else will try to reuse lookahead token after shifting the error
2134      token.  */
2135   goto yyerrlab1;
2136
2137
2138 /*---------------------------------------------------.
2139 | yyerrorlab -- error raised explicitly by YYERROR.  |
2140 `---------------------------------------------------*/
2141 yyerrorlab:
2142
2143   /* Pacify compilers like GCC when the user code never invokes
2144      YYERROR and the label yyerrorlab therefore never appears in user
2145      code.  */
2146   if (/*CONSTCOND*/ 0)
2147      goto yyerrorlab;
2148
2149   /* Do not reclaim the symbols of the rule which action triggered
2150      this YYERROR.  */
2151   YYPOPSTACK (yylen);
2152   yylen = 0;
2153   YY_STACK_PRINT (yyss, yyssp);
2154   yystate = *yyssp;
2155   goto yyerrlab1;
2156
2157
2158 /*-------------------------------------------------------------.
2159 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
2160 `-------------------------------------------------------------*/
2161 yyerrlab1:
2162   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
2163
2164   for (;;)
2165     {
2166       yyn = yypact[yystate];
2167       if (!yypact_value_is_default (yyn))
2168         {
2169           yyn += YYTERROR;
2170           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2171             {
2172               yyn = yytable[yyn];
2173               if (0 < yyn)
2174                 break;
2175             }
2176         }
2177
2178       /* Pop the current state because it cannot handle the error token.  */
2179       if (yyssp == yyss)
2180         YYABORT;
2181
2182
2183       yydestruct ("Error: popping",
2184                   yystos[yystate], yyvsp);
2185       YYPOPSTACK (1);
2186       yystate = *yyssp;
2187       YY_STACK_PRINT (yyss, yyssp);
2188     }
2189
2190   *++yyvsp = yylval;
2191
2192
2193   /* Shift the error token.  */
2194   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2195
2196   yystate = yyn;
2197   goto yynewstate;
2198
2199
2200 /*-------------------------------------.
2201 | yyacceptlab -- YYACCEPT comes here.  |
2202 `-------------------------------------*/
2203 yyacceptlab:
2204   yyresult = 0;
2205   goto yyreturn;
2206
2207 /*-----------------------------------.
2208 | yyabortlab -- YYABORT comes here.  |
2209 `-----------------------------------*/
2210 yyabortlab:
2211   yyresult = 1;
2212   goto yyreturn;
2213
2214 #if !defined(yyoverflow) || YYERROR_VERBOSE
2215 /*-------------------------------------------------.
2216 | yyexhaustedlab -- memory exhaustion comes here.  |
2217 `-------------------------------------------------*/
2218 yyexhaustedlab:
2219   yyerror (YY_("memory exhausted"));
2220   yyresult = 2;
2221   /* Fall through.  */
2222 #endif
2223
2224 yyreturn:
2225   if (yychar != YYEMPTY)
2226     {
2227       /* Make sure we have latest lookahead translation.  See comments at
2228          user semantic actions for why this is necessary.  */
2229       yytoken = YYTRANSLATE (yychar);
2230       yydestruct ("Cleanup: discarding lookahead",
2231                   yytoken, &yylval);
2232     }
2233   /* Do not reclaim the symbols of the rule which action triggered
2234      this YYABORT or YYACCEPT.  */
2235   YYPOPSTACK (yylen);
2236   YY_STACK_PRINT (yyss, yyssp);
2237   while (yyssp != yyss)
2238     {
2239       yydestruct ("Cleanup: popping",
2240                   yystos[*yyssp], yyvsp);
2241       YYPOPSTACK (1);
2242     }
2243 #ifndef yyoverflow
2244   if (yyss != yyssa)
2245     YYSTACK_FREE (yyss);
2246 #endif
2247 #if YYERROR_VERBOSE
2248   if (yymsg != yymsgbuf)
2249     YYSTACK_FREE (yymsg);
2250 #endif
2251   /* Make sure YYID is used.  */
2252   return YYID (yyresult);
2253 }
2254
2255
2256
2257 /* Line 2067 of yacc.c  */
2258 #line 547 "i386_parse.y"
2259
2260
2261 static void
2262 yyerror (const char *s)
2263 {
2264   error (0, 0, gettext ("while reading i386 CPU description: %s at line %d"),
2265          gettext (s), i386_lineno);
2266 }
2267
2268
2269 static int
2270 bitfield_compare (const void *p1, const void *p2)
2271 {
2272   struct known_bitfield *f1 = (struct known_bitfield *) p1;
2273   struct known_bitfield *f2 = (struct known_bitfield *) p2;
2274
2275   return strcmp (f1->name, f2->name);
2276 }
2277
2278
2279 static void
2280 new_bitfield (char *name, unsigned long int num)
2281 {
2282   struct known_bitfield *newp = xmalloc (sizeof (struct known_bitfield));
2283   newp->name = name;
2284   newp->bits = num;
2285   newp->tmp = 0;
2286
2287   if (tfind (newp, &bitfields, bitfield_compare) != NULL)
2288     {
2289       error (0, 0, "%d: duplicated definition of bitfield '%s'",
2290              i386_lineno, name);
2291       free (name);
2292       return;
2293     }
2294
2295   if (tsearch (newp, &bitfields, bitfield_compare) == NULL)
2296     error (EXIT_FAILURE, errno, "%d: cannot insert new bitfield '%s'",
2297            i386_lineno, name);
2298 }
2299
2300
2301 /* Check that the number of bits is a multiple of 8.  */
2302 static void
2303 check_bits (struct bitvalue *val)
2304 {
2305   struct bitvalue *runp = val;
2306   unsigned int total = 0;
2307
2308   while (runp != NULL)
2309     {
2310       if (runp->type == zeroone)
2311         ++total;
2312       else if (runp->field == NULL)
2313         /* No sense doing anything, the field is not known.  */
2314         return;
2315       else
2316         total += runp->field->bits;
2317
2318       runp = runp->next;
2319     }
2320
2321   if (total % 8 != 0)
2322     {
2323       struct obstack os;
2324       obstack_init (&os);
2325
2326       while (val != NULL)
2327         {
2328           if (val->type == zeroone)
2329             obstack_printf (&os, "%u", val->value);
2330           else
2331             obstack_printf (&os, "{%s}", val->field->name);
2332           val = val->next;
2333         }
2334       obstack_1grow (&os, '\0');
2335
2336       error (0, 0, "%d: field '%s' not a multiple of 8 bits in size",
2337              i386_lineno, (char *) obstack_finish (&os));
2338
2339       obstack_free (&os, NULL);
2340     }
2341 }
2342
2343
2344 static int
2345 check_duplicates (struct bitvalue *val)
2346 {
2347   static int testcnt;
2348   ++testcnt;
2349
2350   int result = 0;
2351   while (val != NULL)
2352     {
2353       if (val->type == field && val->field != NULL)
2354         {
2355           if (val->field->tmp == testcnt)
2356             {
2357               error (0, 0, "%d: bitfield '%s' used more than once",
2358                      i386_lineno - 1, val->field->name);
2359               result = 1;
2360             }
2361           val->field->tmp = testcnt;
2362         }
2363
2364       val = val->next;
2365     }
2366
2367   return result;
2368 }
2369
2370
2371 static int
2372 check_argsdef (struct bitvalue *bitval, struct argument *args)
2373 {
2374   int result = 0;
2375
2376   while (args != NULL)
2377     {
2378       for (struct argname *name = args->name; name != NULL; name = name->next)
2379         if (name->type == nfield && name->field != NULL
2380             && name->field != &ax_reg && name->field != &dx_reg
2381             && name->field != &di_reg && name->field != &si_reg
2382             && name->field != &bx_reg)
2383           {
2384             struct bitvalue *runp = bitval;
2385
2386             while (runp != NULL)
2387               if (runp->type == field && runp->field == name->field)
2388                 break;
2389               else
2390                 runp = runp->next;
2391
2392             if (runp == NULL)
2393               {
2394                 error (0, 0, "%d: unknown bitfield '%s' used in output format",
2395                        i386_lineno - 1, name->field->name);
2396                 result = 1;
2397               }
2398           }
2399
2400       args = args->next;
2401     }
2402
2403   return result;
2404 }
2405
2406
2407 static int
2408 check_bitsused (struct bitvalue *bitval, struct known_bitfield *suffix,
2409                 struct argument *args)
2410 {
2411   int result = 0;
2412
2413   while (bitval != NULL)
2414     {
2415       if (bitval->type == field && bitval->field != NULL
2416           && bitval->field != suffix
2417           /* {w} is handled special.  */
2418           && strcmp (bitval->field->name, "w") != 0)
2419         {
2420           struct argument *runp;
2421           for (runp = args; runp != NULL; runp = runp->next)
2422             {
2423               struct argname *name = runp->name;
2424
2425               while (name != NULL)
2426                 if (name->type == nfield && name->field == bitval->field)
2427                   break;
2428                 else
2429                   name = name->next;
2430
2431               if (name != NULL)
2432                 break;
2433             }
2434
2435 #if 0
2436           if (runp == NULL)
2437             {
2438               error (0, 0, "%d: bitfield '%s' not used",
2439                      i386_lineno - 1, bitval->field->name);
2440               result = 1;
2441             }
2442 #endif
2443         }
2444
2445       bitval = bitval->next;
2446     }
2447
2448   return result;
2449 }
2450
2451
2452 static struct argname *
2453 combine (struct argname *name)
2454 {
2455   struct argname *last_str = NULL;
2456   for (struct argname *runp = name; runp != NULL; runp = runp->next)
2457     {
2458       if (runp->type == string)
2459         {
2460           if (last_str == NULL)
2461             last_str = runp;
2462           else
2463             {
2464               last_str->str = xrealloc (last_str->str,
2465                                         strlen (last_str->str)
2466                                         + strlen (runp->str) + 1);
2467               strcat (last_str->str, runp->str);
2468               last_str->next = runp->next;
2469             }
2470         }
2471       else
2472         last_str = NULL;
2473     }
2474   return name;
2475 }
2476
2477
2478 #define obstack_grow_str(ob, str) obstack_grow (ob, str, strlen (str))
2479
2480
2481 static void
2482 fillin_arg (struct bitvalue *bytes, struct argname *name,
2483             struct instruction *instr, int n)
2484 {
2485   static struct obstack ob;
2486   static int initialized;
2487   if (! initialized)
2488     {
2489       initialized = 1;
2490       obstack_init (&ob);
2491     }
2492
2493   struct argname *runp = name;
2494   int cnt = 0;
2495   while (runp != NULL)
2496     {
2497       /* We ignore strings in the function name.  */
2498       if (runp->type == string)
2499         {
2500           if (instr->operands[n].str != NULL)
2501             error (EXIT_FAILURE, 0,
2502                    "%d: cannot have more than one string parameter",
2503                    i386_lineno - 1);
2504
2505           instr->operands[n].str = runp->str;
2506         }
2507       else
2508         {
2509           assert (runp->type == nfield);
2510
2511           /* Construct the function name.  */
2512           if (cnt++ > 0)
2513             obstack_1grow (&ob, '$');
2514
2515           if (runp->field == NULL)
2516             /* Add some string which contains invalid characters.  */
2517             obstack_grow_str (&ob, "!!!INVALID!!!");
2518           else
2519             {
2520               char *fieldname = runp->field->name;
2521
2522               struct synonym search = { .from = fieldname };
2523
2524               struct synonym **res = tfind (&search, &synonyms, compare_syn);
2525               if (res != NULL)
2526                 fieldname = (*res)->to;
2527
2528               obstack_grow_str (&ob, fieldname);
2529             }
2530
2531           /* Now compute the bit offset of the field.  */
2532           struct bitvalue *b = bytes;
2533           int bitoff = 0;
2534           if (runp->field != NULL)
2535             while (b != NULL)
2536               {
2537                 if (b->type == field && b->field != NULL)
2538                   {
2539                     if (strcmp (b->field->name, runp->field->name) == 0)
2540                       break;
2541                     bitoff += b->field->bits;
2542                   }
2543                 else
2544                   ++bitoff;
2545
2546                 b = b->next;
2547               }
2548           if (instr->operands[n].off1 == 0)
2549             instr->operands[n].off1 = bitoff;
2550           else if (instr->operands[n].off2 == 0)
2551             instr->operands[n].off2 = bitoff;
2552           else if (instr->operands[n].off3 == 0)
2553             instr->operands[n].off3 = bitoff;
2554           else
2555             error (EXIT_FAILURE, 0,
2556                    "%d: cannot have more than three fields in parameter",
2557                    i386_lineno - 1);
2558
2559           if  (runp->field != NULL
2560                && strncasecmp (runp->field->name, "mod", 3) == 0)
2561             instr->modrm = 1;
2562         }
2563
2564       runp = runp->next;
2565     }
2566   if (obstack_object_size (&ob) == 0)
2567     obstack_grow_str (&ob, "string");
2568   obstack_1grow (&ob, '\0');
2569   char *fct = obstack_finish (&ob);
2570
2571   instr->operands[n].fct = fct;
2572 }
2573
2574
2575 #if 0
2576 static void
2577 nameout (const void *nodep, VISIT value, int level)
2578 {
2579   if (value == leaf || value == postorder)
2580     printf ("  %s\n", *(const char **) nodep);
2581 }
2582 #endif
2583
2584
2585 static int
2586 compare_argstring (const void *p1, const void *p2)
2587 {
2588   const struct argstring *a1 = (const struct argstring *) p1;
2589   const struct argstring *a2 = (const struct argstring *) p2;
2590
2591   return strcmp (a1->str, a2->str);
2592 }
2593
2594
2595 static int maxoff[3][3];
2596 static int minoff[3][3] = { { 1000, 1000, 1000 },
2597                             { 1000, 1000, 1000 },
2598                             { 1000, 1000, 1000 } };
2599 static int nbitoff[3][3];
2600 static void *fct_names[3];
2601 static int nbitfct[3];
2602 static int nbitsuf;
2603 static void *strs[3];
2604 static int nbitstr[3];
2605 static int total_bits = 2;      // Already counted the rep/repe bits.
2606
2607 static void
2608 find_numbers (void)
2609 {
2610   int nfct_names[3] = { 0, 0, 0 };
2611   int nstrs[3] = { 0, 0, 0 };
2612
2613   /* We reverse the order of the instruction list while processing it.
2614      Later phases need it in the order in which the input file has
2615      them.  */
2616   struct instruction *reversed = NULL;
2617
2618   struct instruction *runp = instructions;
2619   while (runp != NULL)
2620     {
2621       for (int i = 0; i < 3; ++i)
2622         if (runp->operands[i].fct != NULL)
2623           {
2624             struct argstring search = { .str = runp->operands[i].fct };
2625             if (tfind (&search, &fct_names[i], compare_argstring) == NULL)
2626               {
2627                 struct argstring *newp = xmalloc (sizeof (*newp));
2628                 newp->str = runp->operands[i].fct;
2629                 newp->idx = 0;
2630                 if (tsearch (newp, &fct_names[i], compare_argstring) == NULL)
2631                   error (EXIT_FAILURE, errno, "tsearch");
2632                 ++nfct_names[i];
2633               }
2634
2635             if (runp->operands[i].str != NULL)
2636               {
2637                 search.str = runp->operands[i].str;
2638                 if (tfind (&search, &strs[i], compare_argstring) == NULL)
2639                   {
2640                     struct argstring *newp = xmalloc (sizeof (*newp));
2641                     newp->str = runp->operands[i].str;
2642                     newp->idx = 0;
2643                     if (tsearch (newp, &strs[i], compare_argstring) == NULL)
2644                       error (EXIT_FAILURE, errno, "tsearch");
2645                     ++nstrs[i];
2646                   }
2647               }
2648
2649             maxoff[i][0] = MAX (maxoff[i][0], runp->operands[i].off1);
2650             maxoff[i][1] = MAX (maxoff[i][1], runp->operands[i].off2);
2651             maxoff[i][2] = MAX (maxoff[i][2], runp->operands[i].off3);
2652
2653             if (runp->operands[i].off1 > 0)
2654               minoff[i][0] = MIN (minoff[i][0], runp->operands[i].off1);
2655             if (runp->operands[i].off2 > 0)
2656               minoff[i][1] = MIN (minoff[i][1], runp->operands[i].off2);
2657             if (runp->operands[i].off3 > 0)
2658               minoff[i][2] = MIN (minoff[i][2], runp->operands[i].off3);
2659           }
2660
2661       struct instruction *old = runp;
2662       runp = runp->next;
2663
2664       old->next = reversed;
2665       reversed = old;
2666     }
2667   instructions = reversed;
2668
2669   int d;
2670   int c;
2671   for (int i = 0; i < 3; ++i)
2672     {
2673       // printf ("min1 = %d, min2 = %d, min3 = %d\n", minoff[i][0], minoff[i][1], minoff[i][2]);
2674       // printf ("max1 = %d, max2 = %d, max3 = %d\n", maxoff[i][0], maxoff[i][1], maxoff[i][2]);
2675
2676       if (minoff[i][0] == 1000)
2677         nbitoff[i][0] = 0;
2678       else
2679         {
2680           nbitoff[i][0] = 1;
2681           d = maxoff[i][0] - minoff[i][0];
2682           c = 1;
2683           while (c < d)
2684             {
2685               ++nbitoff[i][0];
2686               c *= 2;
2687             }
2688           total_bits += nbitoff[i][0];
2689         }
2690
2691       if (minoff[i][1] == 1000)
2692         nbitoff[i][1] = 0;
2693       else
2694         {
2695           nbitoff[i][1] = 1;
2696           d = maxoff[i][1] - minoff[i][1];
2697           c = 1;
2698           while (c < d)
2699             {
2700               ++nbitoff[i][1];
2701               c *= 2;
2702             }
2703           total_bits += nbitoff[i][1];
2704         }
2705
2706       if (minoff[i][2] == 1000)
2707         nbitoff[i][2] = 0;
2708       else
2709         {
2710           nbitoff[i][2] = 1;
2711           d = maxoff[i][2] - minoff[i][2];
2712           c = 1;
2713           while (c < d)
2714             {
2715               ++nbitoff[i][2];
2716               c *= 2;
2717             }
2718           total_bits += nbitoff[i][2];
2719         }
2720       // printf ("off1 = %d, off2 = %d, off3 = %d\n", nbitoff[i][0], nbitoff[i][1], nbitoff[i][2]);
2721
2722       nbitfct[i] = 1;
2723       d = nfct_names[i];
2724       c = 1;
2725       while (c < d)
2726         {
2727           ++nbitfct[i];
2728           c *= 2;
2729         }
2730       total_bits += nbitfct[i];
2731       // printf ("%d fct[%d], %d bits\n", nfct_names[i], i, nbitfct[i]);
2732
2733       if (nstrs[i] != 0)
2734         {
2735           nbitstr[i] = 1;
2736           d = nstrs[i];
2737           c = 1;
2738           while (c < d)
2739             {
2740               ++nbitstr[i];
2741               c *= 2;
2742             }
2743           total_bits += nbitstr[i];
2744         }
2745
2746       // twalk (fct_names[i], nameout);
2747     }
2748
2749   nbitsuf = 0;
2750   d = nsuffixes;
2751   c = 1;
2752   while (c < d)
2753     {
2754       ++nbitsuf;
2755       c *= 2;
2756     }
2757   total_bits += nbitsuf;
2758   // printf ("%d suffixes, %d bits\n", nsuffixes, nbitsuf);
2759 }
2760
2761
2762 static int
2763 compare_syn (const void *p1, const void *p2)
2764 {
2765   const struct synonym *s1 = (const struct synonym *) p1;
2766   const struct synonym *s2 = (const struct synonym *) p2;
2767
2768   return strcmp (s1->from, s2->from);
2769 }
2770
2771
2772 static int
2773 compare_suf (const void *p1, const void *p2)
2774 {
2775   const struct suffix *s1 = (const struct suffix *) p1;
2776   const struct suffix *s2 = (const struct suffix *) p2;
2777
2778   return strcmp (s1->name, s2->name);
2779 }
2780
2781
2782 static int count_op_str;
2783 static int off_op_str;
2784 static void
2785 print_op_str (const void *nodep, VISIT value,
2786               int level __attribute__ ((unused)))
2787 {
2788   if (value == leaf || value == postorder)
2789     {
2790       const char *str = (*(struct argstring **) nodep)->str;
2791       fprintf (outfile, "%s\n  \"%s",
2792                count_op_str == 0 ? "" : "\\0\"", str);
2793       (*(struct argstring **) nodep)->idx = ++count_op_str;
2794       (*(struct argstring **) nodep)->off = off_op_str;
2795       off_op_str += strlen (str) + 1;
2796     }
2797 }
2798
2799
2800 static void
2801 print_op_str_idx (const void *nodep, VISIT value,
2802                   int level __attribute__ ((unused)))
2803 {
2804   if (value == leaf || value == postorder)
2805     printf ("  %d,\n", (*(struct argstring **) nodep)->off);
2806 }
2807
2808
2809 static void
2810 print_op_fct (const void *nodep, VISIT value,
2811               int level __attribute__ ((unused)))
2812 {
2813   if (value == leaf || value == postorder)
2814     {
2815       fprintf (outfile, "  FCT_%s,\n", (*(struct argstring **) nodep)->str);
2816       (*(struct argstring **) nodep)->idx = ++count_op_str;
2817     }
2818 }
2819
2820
2821 #if NMNES < 2
2822 # error "bogus NMNES value"
2823 #endif
2824
2825 static void
2826 instrtable_out (void)
2827 {
2828   find_numbers ();
2829
2830 #if 0
2831   create_mnemonic_table ();
2832
2833   fprintf (outfile, "#define MNEMONIC_BITS %zu\n", best_mnemonic_bits);
2834 #else
2835   fprintf (outfile, "#define MNEMONIC_BITS %ld\n",
2836            lrint (ceil (log2 (NMNES))));
2837 #endif
2838   fprintf (outfile, "#define SUFFIX_BITS %d\n", nbitsuf);
2839   for (int i = 0; i < 3; ++i)
2840     {
2841       fprintf (outfile, "#define FCT%d_BITS %d\n", i + 1, nbitfct[i]);
2842       if (nbitstr[i] != 0)
2843         fprintf (outfile, "#define STR%d_BITS %d\n", i + 1, nbitstr[i]);
2844       fprintf (outfile, "#define OFF%d_1_BITS %d\n", i + 1, nbitoff[i][0]);
2845       fprintf (outfile, "#define OFF%d_1_BIAS %d\n", i + 1, minoff[i][0]);
2846       if (nbitoff[i][1] != 0)
2847         {
2848           fprintf (outfile, "#define OFF%d_2_BITS %d\n", i + 1, nbitoff[i][1]);
2849           fprintf (outfile, "#define OFF%d_2_BIAS %d\n", i + 1, minoff[i][1]);
2850         }
2851       if (nbitoff[i][2] != 0)
2852         {
2853           fprintf (outfile, "#define OFF%d_3_BITS %d\n", i + 1, nbitoff[i][2]);
2854           fprintf (outfile, "#define OFF%d_3_BIAS %d\n", i + 1, minoff[i][2]);
2855         }
2856     }
2857
2858   fputs ("\n#include <i386_data.h>\n\n", outfile);
2859
2860
2861 #define APPEND(a, b) APPEND_ (a, b)
2862 #define APPEND_(a, b) a##b
2863 #define EMIT_SUFFIX(suf) \
2864   fprintf (outfile, "#define suffix_%s %d\n", #suf, APPEND (suffix_, suf))
2865   EMIT_SUFFIX (none);
2866   EMIT_SUFFIX (w);
2867   EMIT_SUFFIX (w0);
2868   EMIT_SUFFIX (W);
2869   EMIT_SUFFIX (tttn);
2870   EMIT_SUFFIX (D);
2871   EMIT_SUFFIX (w1);
2872   EMIT_SUFFIX (W1);
2873
2874   fputc_unlocked ('\n', outfile);
2875
2876   for (int i = 0; i < 3; ++i)
2877     {
2878       /* Functions.  */
2879       count_op_str = 0;
2880       fprintf (outfile, "static const opfct_t op%d_fct[] =\n{\n  NULL,\n",
2881                i + 1);
2882       twalk (fct_names[i], print_op_fct);
2883       fputs ("};\n", outfile);
2884
2885       /* The operand strings.  */
2886       if (nbitstr[i] != 0)
2887         {
2888           count_op_str = 0;
2889           off_op_str = 0;
2890           fprintf (outfile, "static const char op%d_str[] =", i + 1);
2891           twalk (strs[i], print_op_str);
2892           fputs ("\";\n", outfile);
2893
2894           fprintf (outfile, "static const uint8_t op%d_str_idx[] = {\n",
2895                    i + 1);
2896           twalk (strs[i], print_op_str_idx);
2897           fputs ("};\n", outfile);
2898         }
2899     }
2900
2901
2902   fputs ("static const struct instr_enc instrtab[] =\n{\n", outfile);
2903   struct instruction *instr;
2904   for (instr = instructions; instr != NULL; instr = instr->next)
2905     {
2906       fputs ("  {", outfile);
2907       if (instr->mnemonic == (void *) -1l)
2908         fputs (" .mnemonic = MNE_INVALID,", outfile);
2909       else
2910         fprintf (outfile, " .mnemonic = MNE_%s,", instr->mnemonic);
2911       fprintf (outfile, " .rep = %d,", instr->rep);
2912       fprintf (outfile, " .repe = %d,", instr->repe);
2913       fprintf (outfile, " .suffix = %d,", instr->suffix);
2914       fprintf (outfile, " .modrm = %d,", instr->modrm);
2915
2916       for (int i = 0; i < 3; ++i)
2917         {
2918           int idx = 0;
2919           if (instr->operands[i].fct != NULL)
2920             {
2921               struct argstring search = { .str = instr->operands[i].fct };
2922               struct argstring **res = tfind (&search, &fct_names[i],
2923                                               compare_argstring);
2924               assert (res != NULL);
2925               idx = (*res)->idx;
2926             }
2927           fprintf (outfile, " .fct%d = %d,", i + 1, idx);
2928
2929           idx = 0;
2930           if (instr->operands[i].str != NULL)
2931             {
2932               struct argstring search = { .str = instr->operands[i].str };
2933               struct argstring **res = tfind (&search, &strs[i],
2934                                               compare_argstring);
2935               assert (res != NULL);
2936               idx = (*res)->idx;
2937             }
2938           if (nbitstr[i] != 0)
2939             fprintf (outfile, " .str%d = %d,", i + 1, idx);
2940
2941           fprintf (outfile, " .off%d_1 = %d,", i + 1,
2942                    MAX (0, instr->operands[i].off1 - minoff[i][0]));
2943
2944           if (nbitoff[i][1] != 0)
2945             fprintf (outfile, " .off%d_2 = %d,", i + 1,
2946                      MAX (0, instr->operands[i].off2 - minoff[i][1]));
2947
2948           if (nbitoff[i][2] != 0)
2949             fprintf (outfile, " .off%d_3 = %d,", i + 1,
2950                      MAX (0, instr->operands[i].off3 - minoff[i][2]));
2951         }
2952
2953       fputs (" },\n", outfile);
2954     }
2955   fputs ("};\n", outfile);
2956
2957   fputs ("static const uint8_t match_data[] =\n{\n", outfile);
2958   size_t cnt = 0;
2959   for (instr = instructions; instr != NULL; instr = instr->next, ++cnt)
2960     {
2961       /* First count the number of bytes.  */
2962       size_t totalbits = 0;
2963       size_t zerobits = 0;
2964       bool leading_p = true;
2965       size_t leadingbits = 0;
2966       struct bitvalue *b = instr->bytes;
2967       while (b != NULL)
2968         {
2969           if (b->type == zeroone)
2970             {
2971               ++totalbits;
2972               zerobits = 0;
2973               if (leading_p)
2974                 ++leadingbits;
2975             }
2976           else
2977             {
2978               totalbits += b->field->bits;
2979               /* We must always count the mod/rm byte.  */
2980               if (strncasecmp (b->field->name, "mod", 3) == 0)
2981                 zerobits = 0;
2982               else
2983                 zerobits += b->field->bits;
2984               leading_p = false;
2985             }
2986           b = b->next;
2987         }
2988       size_t nbytes = (totalbits - zerobits + 7) / 8;
2989       assert (nbytes > 0);
2990       size_t leadingbytes = leadingbits / 8;
2991
2992       fprintf (outfile, "  %#zx,", nbytes | (leadingbytes << 4));
2993
2994       /* Now create the mask and byte values.  */
2995       uint8_t byte = 0;
2996       uint8_t mask = 0;
2997       int nbits = 0;
2998       b = instr->bytes;
2999       while (b != NULL)
3000         {
3001           if (b->type == zeroone)
3002             {
3003               byte = (byte << 1) | b->value;
3004               mask = (mask << 1) | 1;
3005               if (++nbits == 8)
3006                 {
3007                   if (leadingbytes > 0)
3008                     {
3009                       assert (mask == 0xff);
3010                       fprintf (outfile, " %#" PRIx8 ",", byte);
3011                       --leadingbytes;
3012                     }
3013                   else
3014                     fprintf (outfile, " %#" PRIx8 ", %#" PRIx8 ",",
3015                              mask, byte);
3016                   byte = mask = nbits = 0;
3017                   if (--nbytes == 0)
3018                     break;
3019                 }
3020             }
3021           else
3022             {
3023               assert (leadingbytes == 0);
3024
3025               unsigned long int remaining = b->field->bits;
3026               while (nbits + remaining > 8)
3027                 {
3028                   fprintf (outfile, " %#" PRIx8 ", %#" PRIx8 ",",
3029                            mask << (8 - nbits), byte << (8 - nbits));
3030                   remaining = nbits + remaining - 8;
3031                   byte = mask = nbits = 0;
3032                   if (--nbytes == 0)
3033                     break;
3034                 }
3035               byte <<= remaining;
3036               mask <<= remaining;
3037               nbits += remaining;
3038               if (nbits == 8)
3039                 {
3040                   fprintf (outfile, " %#" PRIx8 ", %#" PRIx8 ",", mask, byte);
3041                   byte = mask = nbits = 0;
3042                   if (--nbytes == 0)
3043                     break;
3044                 }
3045             }
3046           b = b->next;
3047         }
3048
3049       fputc_unlocked ('\n', outfile);
3050     }
3051   fputs ("};\n", outfile);
3052 }
3053
3054
3055 #if 0
3056 static size_t mnemonic_maxlen;
3057 static size_t mnemonic_minlen;
3058 static size_t
3059 which_chars (const char *str[], size_t nstr)
3060 {
3061   char used_char[256];
3062   memset (used_char, '\0', sizeof (used_char));
3063   mnemonic_maxlen = 0;
3064   mnemonic_minlen = 10000;
3065   for (size_t cnt = 0; cnt < nstr; ++cnt)
3066     {
3067       const unsigned char *cp = (const unsigned char *) str[cnt];
3068       mnemonic_maxlen = MAX (mnemonic_maxlen, strlen ((char *) cp));
3069       mnemonic_minlen = MIN (mnemonic_minlen, strlen ((char *) cp));
3070       do
3071         used_char[*cp++] = 1;
3072       while (*cp != '\0');
3073     }
3074   size_t nused_char = 0;
3075   for (size_t cnt = 0; cnt < 256; ++cnt)
3076     if (used_char[cnt] != 0)
3077       ++nused_char;
3078   return nused_char;
3079 }
3080
3081
3082 static const char **mnemonic_strs;
3083 static size_t nmnemonic_strs;
3084 static void
3085 add_mnemonics (const void *nodep, VISIT value,
3086                int level __attribute__ ((unused)))
3087 {
3088   if (value == leaf || value == postorder)
3089     mnemonic_strs[nmnemonic_strs++] = *(const char **) nodep;
3090 }
3091
3092
3093 struct charfreq
3094 {
3095   char ch;
3096   int freq;
3097 };
3098 static struct charfreq pfxfreq[256];
3099 static struct charfreq sfxfreq[256];
3100
3101
3102 static int
3103 compare_freq (const void *p1, const void *p2)
3104 {
3105   const struct charfreq *c1 = (const struct charfreq *) p1;
3106   const struct charfreq *c2 = (const struct charfreq *) p2;
3107
3108   if (c1->freq > c2->freq)
3109     return -1;
3110   if (c1->freq < c2->freq)
3111     return 1;
3112   return 0;
3113 }
3114
3115
3116 static size_t
3117 compute_pfxfreq (const char *str[], size_t nstr)
3118 {
3119   memset (pfxfreq, '\0', sizeof (pfxfreq));
3120
3121   for (size_t i = 0; i < nstr; ++i)
3122     pfxfreq[i].ch = i;
3123
3124   for (size_t i = 0; i < nstr; ++i)
3125     ++pfxfreq[*((const unsigned char *) str[i])].freq;
3126
3127   qsort (pfxfreq, 256, sizeof (struct charfreq), compare_freq);
3128
3129   size_t n = 0;
3130   while (n < 256 && pfxfreq[n].freq != 0)
3131     ++n;
3132   return n;
3133 }
3134
3135
3136 struct strsnlen
3137 {
3138   const char *str;
3139   size_t len;
3140 };
3141
3142 static size_t
3143 compute_sfxfreq (size_t nstr, struct strsnlen *strsnlen)
3144 {
3145   memset (sfxfreq, '\0', sizeof (sfxfreq));
3146
3147   for (size_t i = 0; i < nstr; ++i)
3148     sfxfreq[i].ch = i;
3149
3150   for (size_t i = 0; i < nstr; ++i)
3151     ++sfxfreq[((const unsigned char *) strchrnul (strsnlen[i].str, '\0'))[-1]].freq;
3152
3153   qsort (sfxfreq, 256, sizeof (struct charfreq), compare_freq);
3154
3155   size_t n = 0;
3156   while (n < 256 && sfxfreq[n].freq != 0)
3157     ++n;
3158   return n;
3159 }
3160
3161
3162 static void
3163 create_mnemonic_table (void)
3164 {
3165   mnemonic_strs = xmalloc (nmnemonics * sizeof (char *));
3166
3167   twalk (mnemonics, add_mnemonics);
3168
3169   (void) which_chars (mnemonic_strs, nmnemonic_strs);
3170
3171   size_t best_so_far = 100000000;
3172   char *best_prefix = NULL;
3173   char *best_suffix = NULL;
3174   char *best_table = NULL;
3175   size_t best_table_size = 0;
3176   size_t best_table_bits = 0;
3177   size_t best_prefix_bits = 0;
3178
3179   /* We can precompute the prefix characters.  */
3180   size_t npfx_char = compute_pfxfreq (mnemonic_strs, nmnemonic_strs);
3181
3182   /* Compute best size for string representation including explicit NUL.  */
3183   for (size_t pfxbits = 0; (1u << pfxbits) < 2 * npfx_char; ++pfxbits)
3184     {
3185       char prefix[1 << pfxbits];
3186       size_t i;
3187       for (i = 0; i < (1u << pfxbits) - 1; ++i)
3188         prefix[i] = pfxfreq[i].ch;
3189       prefix[i] = '\0';
3190
3191       struct strsnlen strsnlen[nmnemonic_strs];
3192
3193       for (i = 0; i < nmnemonic_strs; ++i)
3194         {
3195           if (strchr (prefix, *mnemonic_strs[i]) != NULL)
3196             strsnlen[i].str = mnemonic_strs[i] + 1;
3197           else
3198             strsnlen[i].str = mnemonic_strs[i];
3199           strsnlen[i].len = strlen (strsnlen[i].str);
3200         }
3201
3202       /* With the prefixes gone, try to combine strings.  */
3203       size_t nstrsnlen = 1;
3204       for (i = 1; i < nmnemonic_strs; ++i)
3205         {
3206           size_t j;
3207           for (j = 0; j < nstrsnlen; ++j)
3208             if (strsnlen[i].len > strsnlen[j].len
3209                 && strcmp (strsnlen[j].str,
3210                            strsnlen[i].str + (strsnlen[i].len
3211                                               - strsnlen[j].len)) == 0)
3212               {
3213                 strsnlen[j] = strsnlen[i];
3214                 break;
3215               }
3216             else if (strsnlen[i].len < strsnlen[j].len
3217                      && strcmp (strsnlen[i].str,
3218                                 strsnlen[j].str + (strsnlen[j].len
3219                                                    - strsnlen[i].len)) == 0)
3220               break;
3221 ;
3222           if (j == nstrsnlen)
3223               strsnlen[nstrsnlen++] = strsnlen[i];
3224         }
3225
3226       size_t nsfx_char = compute_sfxfreq (nstrsnlen, strsnlen);
3227
3228       for (size_t sfxbits = 0; (1u << sfxbits) < 2 * nsfx_char; ++sfxbits)
3229         {
3230           char suffix[1 << sfxbits];
3231
3232           for (i = 0; i < (1u << sfxbits) - 1; ++i)
3233             suffix[i] = sfxfreq[i].ch;
3234           suffix[i] = '\0';
3235
3236           size_t newlen[nstrsnlen];
3237
3238           for (i = 0; i < nstrsnlen; ++i)
3239             if (strchr (suffix, strsnlen[i].str[strsnlen[i].len - 1]) != NULL)
3240               newlen[i] = strsnlen[i].len - 1;
3241             else
3242               newlen[i] = strsnlen[i].len;
3243
3244           char charused[256];
3245           memset (charused, '\0', sizeof (charused));
3246           size_t ncharused = 0;
3247
3248           const char *tablestr[nstrsnlen];
3249           size_t ntablestr = 1;
3250           tablestr[0] = strsnlen[0].str;
3251           size_t table = newlen[0] + 1;
3252           for (i = 1; i < nstrsnlen; ++i)
3253             {
3254               size_t j;
3255               for (j = 0; j < ntablestr; ++j)
3256                 if (newlen[i] > newlen[j]
3257                     && memcmp (tablestr[j],
3258                                strsnlen[i].str + (newlen[i] - newlen[j]),
3259                                newlen[j]) == 0)
3260                   {
3261                     table += newlen[i] - newlen[j];
3262                     tablestr[j] = strsnlen[i].str;
3263                     newlen[j] = newlen[i];
3264                     break;
3265                   }
3266                 else if (newlen[i] < newlen[j]
3267                      && memcmp (strsnlen[i].str,
3268                                 tablestr[j] + (newlen[j] - newlen[i]),
3269                                 newlen[i]) == 0)
3270                   break;
3271
3272               if (j == ntablestr)
3273                 {
3274                   table += newlen[i] + 1;
3275                   tablestr[ntablestr] = strsnlen[i].str;
3276                   newlen[ntablestr] = newlen[i];
3277
3278                   ++ntablestr;
3279                 }
3280
3281               for (size_t x = 0; x < newlen[j]; ++x)
3282                 if (charused[((const unsigned char *) tablestr[j])[x]]++ == 0)
3283                   ++ncharused;
3284             }
3285
3286           size_t ncharused_bits = 0;
3287           i = 1;
3288           while (i < ncharused)
3289             {
3290               i *= 2;
3291               ++ncharused_bits;
3292             }
3293
3294           size_t table_bits = 0;
3295           i = 1;
3296           while (i < table)
3297             {
3298               i *= 2;
3299               ++table_bits;
3300             }
3301
3302           size_t mnemonic_bits = table_bits + pfxbits + sfxbits;
3303           size_t new_total = (((table + 7) / 8) * ncharused_bits + ncharused
3304                               + (pfxbits == 0 ? 0 : (1 << pfxbits) - 1)
3305                               + (sfxbits == 0 ? 0 : (1 << sfxbits) - 1)
3306                               + (((total_bits + mnemonic_bits + 7) / 8)
3307                                  * ninstructions));
3308
3309           if (new_total < best_so_far)
3310             {
3311               best_so_far = new_total;
3312               best_mnemonic_bits = mnemonic_bits;
3313
3314               free (best_suffix);
3315               best_suffix = xstrdup (suffix);
3316
3317               free (best_prefix);
3318               best_prefix = xstrdup (prefix);
3319               best_prefix_bits = pfxbits;
3320
3321               best_table_size = table;
3322               best_table_bits = table_bits;
3323               char *cp = best_table = xrealloc (best_table, table);
3324               for (i = 0; i < ntablestr; ++i)
3325                 {
3326                   assert (cp + newlen[i] + 1 <= best_table + table);
3327                   cp = mempcpy (cp, tablestr[i], newlen[i]);
3328                   *cp++ = '\0';
3329                 }
3330               assert (cp == best_table + table);
3331             }
3332         }
3333     }
3334
3335   fputs ("static const char mnemonic_table[] =\n\"", outfile);
3336   for (size_t i = 0; i < best_table_size; ++i)
3337     {
3338       if (((i + 1) % 60) == 0)
3339         fputs ("\"\n\"", outfile);
3340       if (!isascii (best_table[i]) || !isprint (best_table[i]))
3341         fprintf (outfile, "\\%03o", best_table[i]);
3342       else
3343         fputc (best_table[i], outfile);
3344     }
3345   fputs ("\";\n", outfile);
3346
3347   if (best_prefix[0] != '\0')
3348     fprintf (outfile,
3349              "static const char prefix[%zu] = \"%s\";\n"
3350              "#define PREFIXCHAR_BITS %zu\n",
3351              strlen (best_prefix), best_prefix, best_prefix_bits);
3352   else
3353     fputs ("#define NO_PREFIX\n", outfile);
3354
3355   if (best_suffix[0] != '\0')
3356     fprintf (outfile, "static const char suffix[%zu] = \"%s\";\n",
3357              strlen (best_suffix), best_suffix);
3358   else
3359     fputs ("#define NO_SUFFIX\n", outfile);
3360
3361   for (size_t i = 0; i < nmnemonic_strs; ++i)
3362     {
3363       const char *mne = mnemonic_strs[i];
3364
3365       size_t pfxval = 0;
3366       char *cp = strchr (best_prefix, *mne);
3367       if (cp != NULL)
3368         {
3369           pfxval = 1 + (cp - best_prefix);
3370           ++mne;
3371         }
3372
3373       size_t l = strlen (mne);
3374
3375       size_t sfxval = 0;
3376       cp = strchr (best_suffix, mne[l - 1]);
3377       if (cp != NULL)
3378         {
3379           sfxval = 1 + (cp - best_suffix);
3380           --l;
3381         }
3382
3383       char *off = memmem (best_table, best_table_size, mne, l);
3384       while (off[l] != '\0')
3385         {
3386           off = memmem (off + 1, best_table_size, mne, l);
3387           assert (off != NULL);
3388         }
3389
3390       fprintf (outfile, "#define MNE_%s %#zx\n",
3391                mnemonic_strs[i],
3392                (off - best_table)
3393                + ((pfxval + (sfxval << best_prefix_bits)) << best_table_bits));
3394     }
3395 }
3396 #endif
3397