sim/common/sim-options.c

   1 /* Simulator option handling.
   2    Copyright (C) 1996, 1997 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4
   5 This file is part of GDB, the GNU debugger.
   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 2, or (at your option)
  10 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 along
  18 with this program; if not, write to the Free Software Foundation, Inc.,
  19 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "sim-main.h"
  22 #ifdef HAVE_STRING_H
  23 #include <string.h>
  24 #else
  25 #ifdef HAVE_STRINGS_H
  26 #include <strings.h>
  27 #endif
  28 #endif
  29 #include "libiberty.h"
  30 #include "../libiberty/alloca-conf.h"
  31 #include "sim-options.h"
  32 #include "sim-io.h"
  33
  34 /* This is defined in sim-config.h.  */
  35 #ifndef MAX_NR_PROCESSORS
  36 #define MAX_NR_PROCESSORS 1
  37 #endif
  38
  39 /* Add a set of options to the simulator.
  40    TABLE is an array of OPTIONS terminated by a NULL `opt.name' entry.
  41    This is intended to be called by modules in their `install' handler.  */
  42
  43 SIM_RC
  44 sim_add_option_table (sd, table)
  45      SIM_DESC sd;
  46      const OPTION *table;
  47 {
  48   struct option_list *ol = ((struct option_list *)
  49                             xmalloc (sizeof (struct option_list)));
  50
  51   /* Note: The list is constructed in the reverse order we're called so
  52      later calls will override earlier ones (in case that ever happens).
  53      This is the intended behaviour.  */
  54   ol->next = STATE_OPTIONS (sd);
  55   ol->options = table;
  56   STATE_OPTIONS (sd) = ol;
  57
  58   return SIM_RC_OK;
  59 }
  60
  61 /* Standard option table.
  62    Modules may specify additional ones.
  63    The caller of sim_parse_args may also specify additional options
  64    by calling sim_add_option_table first.  */
  65
  66 static DECLARE_OPTION_HANDLER (standard_option_handler);
  67
  68 /* FIXME: We shouldn't print in --help output options that aren't usable.
  69    Some fine tuning will be necessary.  One can either move less general
  70    options to another table or use a HAVE_FOO macro to ifdef out unavailable
  71    options.  */
  72
  73 /* ??? One might want to conditionally compile out the entries that
  74    aren't enabled.  There's a distinction, however, between options a
  75    simulator can't support and options that haven't been configured in.
  76    Certainly options a simulator can't support shouldn't appear in the
  77    output of --help.  Whether the same thing applies to options that haven't
  78    been configured in or not isn't something I can get worked up over.
  79    [Note that conditionally compiling them out might simply involve moving
  80    the option to another table.]
  81    If you decide to conditionally compile them out as well, delete this
  82    comment and add a comment saying that that is the rule.  */
  83
  84 #define OPTION_DEBUG_INSN       (OPTION_START + 0)
  85 #define OPTION_DEBUG_FILE       (OPTION_START + 1)
  86 #define OPTION_TRACE_INSN       (OPTION_START + 2)
  87 #define OPTION_TRACE_DECODE     (OPTION_START + 3)
  88 #define OPTION_TRACE_EXTRACT    (OPTION_START + 4)
  89 #define OPTION_TRACE_LINENUM    (OPTION_START + 5)
  90 #define OPTION_TRACE_MEMORY     (OPTION_START + 6)
  91 #define OPTION_TRACE_MODEL      (OPTION_START + 7)
  92 #define OPTION_TRACE_ALU        (OPTION_START + 8)
  93 #define OPTION_TRACE_FILE       (OPTION_START + 9)
  94 #define OPTION_PROFILE_INSN     (OPTION_START + 10)
  95 #define OPTION_PROFILE_MEMORY   (OPTION_START + 11)
  96 #define OPTION_PROFILE_MODEL    (OPTION_START + 12)
  97 #define OPTION_PROFILE_SIMCACHE (OPTION_START + 13)
  98 #define OPTION_PROFILE_FILE     (OPTION_START + 14)
  99
 100 static const OPTION standard_options[] =
 101 {
 102   { {"verbose", no_argument, NULL, 'v'},
 103       'v', NULL, "Verbose output",
 104       standard_option_handler },
 105
 106 #if defined (SIM_HAVE_BIENDIAN) /* ??? && WITH_TARGET_BYTE_ORDER == 0 */
 107   { {"endian", required_argument, NULL, 'E'},
 108       'E', "big|little", "Set endianness",
 109       standard_option_handler },
 110 #endif
 111
 112   { {"debug", no_argument, NULL, 'D'},
 113       'D', NULL, "Print debugging messages",
 114       standard_option_handler },
 115   { {"debug-insn", no_argument, NULL, OPTION_DEBUG_INSN},
 116       '\0', NULL, "Print instruction debugging messages",
 117       standard_option_handler },
 118   { {"debug-file", required_argument, NULL, OPTION_DEBUG_FILE},
 119       '\0', "FILE NAME", "Specify debugging output file",
 120       standard_option_handler },
 121
 122   { {"trace", no_argument, NULL, 't'},
 123       't', NULL, "Perform tracing",
 124       standard_option_handler },
 125   { {"trace-insn", no_argument, NULL, OPTION_TRACE_INSN},
 126       '\0', NULL, "Perform instruction tracing",
 127       standard_option_handler },
 128   { {"trace-decode", no_argument, NULL, OPTION_TRACE_DECODE},
 129       '\0', NULL, "Perform instruction decoding tracing",
 130       standard_option_handler },
 131   { {"trace-extract", no_argument, NULL, OPTION_TRACE_EXTRACT},
 132       '\0', NULL, "Perform instruction extraction tracing",
 133       standard_option_handler },
 134   { {"trace-linenum", no_argument, NULL, OPTION_TRACE_LINENUM},
 135       '\0', NULL, "Perform line number tracing",
 136       standard_option_handler },
 137   { {"trace-memory", no_argument, NULL, OPTION_TRACE_MEMORY},
 138       '\0', NULL, "Perform memory tracing",
 139       standard_option_handler },
 140   { {"trace-model", no_argument, NULL, OPTION_TRACE_MODEL},
 141       '\0', NULL, "Perform model tracing",
 142       standard_option_handler },
 143   { {"trace-alu", no_argument, NULL, OPTION_TRACE_ALU},
 144       '\0', NULL, "Perform ALU tracing",
 145       standard_option_handler },
 146   { {"trace-file", required_argument, NULL, OPTION_TRACE_FILE},
 147       '\0', "FILE NAME", "Specify tracing output file",
 148       standard_option_handler },
 149
 150 #ifdef SIM_H8300 /* FIXME: Should be movable to h8300 dir.  */
 151   { {"h8300h", no_argument, NULL, 'h'},
 152       'h', NULL, "Indicate the CPU is h8/300h or h8/300s",
 153       standard_option_handler },
 154 #endif
 155
 156 #ifdef SIM_HAVE_SIMCACHE
 157   { {"simcache-size", required_argument, NULL, 'c'},
 158       'c', "SIM CACHE SIZE", "Specify size of simulator execution cache",
 159       standard_option_handler },
 160 #endif
 161
 162 #ifdef SIM_HAVE_FLATMEM
 163   { {"mem-size", required_argument, NULL, 'm'},
 164       'm', "MEMORY SIZE", "Specify memory size",
 165       standard_option_handler },
 166 #endif
 167
 168 #ifdef SIM_HAVE_MAX_INSNS
 169   { {"max-insns", required_argument, NULL, 'M'},
 170       'M', "MAX INSNS", "Specify maximum number of instructions to execute",
 171       standard_option_handler },
 172 #endif
 173
 174 #ifdef SIM_HAVE_PROFILE
 175   { {"profile", no_argument, NULL, 'p'},
 176       'p', NULL, "Perform profiling",
 177       standard_option_handler },
 178   { {"profile-insn", no_argument, NULL, OPTION_PROFILE_INSN},
 179       '\0', NULL, "Perform instruction profiling",
 180       standard_option_handler },
 181   { {"profile-memory", no_argument, NULL, OPTION_PROFILE_MEMORY},
 182       '\0', NULL, "Perform memory profiling",
 183       standard_option_handler },
 184   { {"profile-model", no_argument, NULL, OPTION_PROFILE_MODEL},
 185       '\0', NULL, "Perform model profiling",
 186       standard_option_handler },
 187   { {"profile-simcache", no_argument, NULL, OPTION_PROFILE_SIMCACHE},
 188       '\0', NULL, "Perform simulator execution cache profiling",
 189       standard_option_handler },
 190   { {"profile-file", required_argument, NULL, OPTION_PROFILE_FILE},
 191       '\0', "FILE NAME", "Specify profile output file",
 192       standard_option_handler },
 193 #ifdef SIM_HAVE_PROFILE_PC
 194   { {"profile-pc-frequency", required_argument, NULL, 'F'},
 195       'F', "PC PROFILE FREQUENCY", "Turn on PC profiling at specified frequency",
 196       standard_option_handler },
 197   { {"profile-pc-size", required_argument, NULL, 'S'},
 198       'S', "PC PROFILE SIZE", "Specify PC profiling size",
 199       standard_option_handler },
 200 #endif
 201 #endif /* SIM_HAVE_PROFILE */
 202
 203   { {"help", no_argument, NULL, 'H'},
 204       'H', NULL, "Print help information",
 205       standard_option_handler },
 206
 207   { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL }
 208 };
 209
 210 static SIM_RC
 211 standard_option_handler (sd, opt, arg)
 212      SIM_DESC sd;
 213      int opt;
 214      char *arg;
 215 {
 216   int i,n;
 217   unsigned long ul;
 218
 219   switch (opt)
 220     {
 221     case 'v' :
 222       STATE_VERBOSE_P (sd) = 1;
 223       break;
 224
 225 #ifdef SIM_HAVE_BIENDIAN
 226     case 'E' :
 227       if (strcmp (arg, "big") == 0)
 228         {
 229           if (WITH_TARGET_BYTE_ORDER == LITTLE_ENDIAN)
 230             {
 231               sim_io_eprintf (sd, "Simulator compiled for little endian only.\n");
 232               return SIM_RC_FAIL;
 233             }
 234           /* FIXME:wip: Need to set something in STATE_CONFIG.  */
 235         }
 236       else if (strcmp (arg, "little") == 0)
 237         {
 238           if (WITH_TARGET_BYTE_ORDER == BIG_ENDIAN)
 239             {
 240               sim_io_eprintf (sd, "Simulator compiled for big endian only.\n");
 241               return SIM_RC_FAIL;
 242             }
 243           /* FIXME:wip: Need to set something in STATE_CONFIG.  */
 244         }
 245       else
 246         {
 247           sim_io_eprintf (sd, "Invalid endian specification `%s'\n", arg);
 248           return SIM_RC_FAIL;
 249         }
 250       break;
 251 #endif
 252
 253     case 'D' :
 254       if (! WITH_DEBUG)
 255         sim_io_eprintf (sd, "Debugging not compiled in, `-D' ignored\n");
 256       else
 257         {
 258           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 259             for (i = 0; i < MAX_DEBUG_VALUES; ++i)
 260               CPU_DEBUG_FLAGS (STATE_CPU (sd, n))[i] = 1;
 261         }
 262       break;
 263
 264     case OPTION_DEBUG_INSN :
 265       if (! WITH_DEBUG)
 266         sim_io_eprintf (sd, "Debugging not compiled in, `--debug-insn' ignored\n");
 267       else
 268         {
 269           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 270             CPU_DEBUG_FLAGS (STATE_CPU (sd, n))[DEBUG_INSN_IDX] = 1;
 271         }
 272       break;
 273
 274     case OPTION_DEBUG_FILE :
 275       if (! WITH_DEBUG)
 276         sim_io_eprintf (sd, "Debugging not compiled in, `--debug-file' ignored\n");
 277       else
 278         {
 279           FILE *f = fopen (arg, "w");
 280
 281           if (f == NULL)
 282             {
 283               sim_io_eprintf (sd, "Unable to open debug output file `%s'\n", arg);
 284               return SIM_RC_FAIL;
 285             }
 286           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 287             CPU_DEBUG_FILE (STATE_CPU (sd, n)) = f;
 288         }
 289       break;
 290
 291     case 't' :
 292       if (! WITH_TRACE)
 293         sim_io_eprintf (sd, "Tracing not compiled in, `-t' ignored\n");
 294       else
 295         {
 296           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 297             for (i = 0; i < MAX_TRACE_VALUES; ++i)
 298               CPU_TRACE_FLAGS (STATE_CPU (sd, n))[i] = 1;
 299         }
 300       break;
 301
 302     case OPTION_TRACE_INSN :
 303       if (! (WITH_TRACE & (1 << TRACE_INSN_IDX)))
 304         sim_io_eprintf (sd, "Instruction tracing not compiled in, `--trace-insn' ignored\n");
 305       else
 306         {
 307           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 308             CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_INSN_IDX] = 1;
 309         }
 310       break;
 311
 312     case OPTION_TRACE_DECODE :
 313       if (! (WITH_TRACE & (1 << TRACE_DECODE_IDX)))
 314         sim_io_eprintf (sd, "Decode tracing not compiled in, `--trace-decode' ignored\n");
 315       else
 316         {
 317           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 318             CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_DECODE_IDX] = 1;
 319         }
 320       break;
 321
 322     case OPTION_TRACE_EXTRACT :
 323       if (! (WITH_TRACE & (1 << TRACE_EXTRACT_IDX)))
 324         sim_io_eprintf (sd, "Extract tracing not compiled in, `--trace-extract' ignored\n");
 325       else
 326         {
 327           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 328             CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_EXTRACT_IDX] = 1;
 329         }
 330       break;
 331
 332     case OPTION_TRACE_LINENUM :
 333       if (! (WITH_TRACE & (1 << TRACE_LINENUM_IDX)))
 334         sim_io_eprintf (sd, "Line number tracing not compiled in, `--trace-linenum' ignored\n");
 335       else
 336         {
 337           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 338             CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_LINENUM_IDX] = 1;
 339         }
 340       break;
 341
 342     case OPTION_TRACE_MEMORY :
 343       if (! (WITH_TRACE & (1 << TRACE_MEMORY_IDX)))
 344         sim_io_eprintf (sd, "Memory tracing not compiled in, `--trace-memory' ignored\n");
 345       else
 346         {
 347           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 348             CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_MEMORY_IDX] = 1;
 349         }
 350       break;
 351
 352     case OPTION_TRACE_MODEL :
 353       if (! (WITH_TRACE & (1 << TRACE_MODEL_IDX)))
 354         sim_io_eprintf (sd, "Model tracing not compiled in, `--trace-model' ignored\n");
 355       else
 356         {
 357           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 358             CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_MODEL_IDX] = 1;
 359         }
 360       break;
 361
 362     case OPTION_TRACE_ALU :
 363       if (! (WITH_TRACE & (1 << TRACE_ALU_IDX)))
 364         sim_io_eprintf (sd, "ALU tracing not compiled in, `--trace-alu' ignored\n");
 365       else
 366         {
 367           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 368             CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_ALU_IDX] = 1;
 369         }
 370       break;
 371
 372     case OPTION_TRACE_FILE :
 373       if (! WITH_TRACE)
 374         sim_io_eprintf (sd, "Tracing not compiled in, `--trace-file' ignored\n");
 375       else
 376         {
 377           FILE *f = fopen (arg, "w");
 378
 379           if (f == NULL)
 380             {
 381               sim_io_eprintf (sd, "Unable to open trace output file `%s'\n", arg);
 382               return SIM_RC_FAIL;
 383             }
 384           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 385             CPU_TRACE_FILE (STATE_CPU (sd, n)) = f;
 386         }
 387       break;
 388
 389 #ifdef SIM_H8300 /* FIXME: Can be moved to h8300 dir.  */
 390     case 'h' :
 391       set_h8300h (1);
 392       break;
 393 #endif
 394
 395 #ifdef SIM_HAVE_SIMCACHE
 396     case 'c':
 397       n = strtol (arg, NULL, 0);
 398       if (n <= 0)
 399         {
 400           sim_io_eprintf (sd, "Invalid simulator cache size: %d", n);
 401           return SIM_RC_FAIL;
 402         }
 403       STATE_SIMCACHE_SIZE (sd) = n;
 404       break;
 405 #endif
 406
 407 #ifdef SIM_HAVE_FLATMEM
 408     case 'm':
 409       ul = strtol (arg, NULL, 0);
 410       /* 16384: some minimal amount */
 411       if (! isdigit (arg[0]) || ul < 16384)
 412         {
 413           sim_io_eprintf (sd, "Invalid memory size `%s'", arg);
 414           return SIM_RC_FAIL;
 415         }
 416       STATE_MEM_SIZE (sd) = ul;
 417       break;
 418 #endif
 419
 420 #ifdef SIM_HAVE_MAX_INSNS
 421     case 'M' :
 422       ul = strtoul (arg, NULL, 0);
 423       if (! isdigit (arg[0]))
 424         {
 425           sim_io_eprintf (sd, "Invalid maximum instruction count: `%s'", arg);
 426           return SIM_RC_FAIL;
 427         }
 428       STATE_MAX_INSNS (sd) = ul;
 429       break;
 430 #endif
 431
 432 #ifdef SIM_HAVE_PROFILE
 433     case 'p' :
 434       if (! WITH_PROFILE)
 435         sim_io_eprintf (sd, "Profile not compiled in, -p option ignored\n");
 436       else
 437         {
 438           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 439             for (i = 0; i < MAX_PROFILE_VALUES; ++i)
 440               CPU_PROFILE_FLAGS (STATE_CPU (sd, n))[i] = 1;
 441         }
 442       break;
 443
 444     case OPTION_PROFILE_INSN :
 445       if (! (WITH_PROFILE & (1 << PROFILE_INSN_IDX)))
 446         sim_io_eprintf (sd, "Instruction profiling not compiled in, `--profile-insn' ignored\n");
 447       else
 448         {
 449           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 450             CPU_PROFILE_FLAGS (STATE_CPU (sd, n))[PROFILE_INSN_IDX] = 1;
 451         }
 452       break;
 453
 454     case OPTION_PROFILE_MEMORY :
 455       if (! (WITH_PROFILE & (1 << PROFILE_MEMORY_IDX)))
 456         sim_io_eprintf (sd, "Memory profiling not compiled in, `--profile-memory' ignored\n");
 457       else
 458         {
 459           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 460             CPU_PROFILE_FLAGS (STATE_CPU (sd, n))[PROFILE_MEMORY_IDX] = 1;
 461         }
 462       break;
 463
 464     case OPTION_PROFILE_MODEL :
 465       if (! (WITH_PROFILE & (1 << PROFILE_MODEL_IDX)))
 466         sim_io_eprintf (sd, "Model profiling not compiled in, `--profile-model' ignored\n");
 467       else
 468         {
 469           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 470             CPU_PROFILE_FLAGS (STATE_CPU (sd, n))[PROFILE_MODEL_IDX] = 1;
 471         }
 472       break;
 473
 474     case OPTION_PROFILE_SIMCACHE :
 475       if (! (WITH_PROFILE & (1 << PROFILE_SIMCACHE_IDX)))
 476         sim_io_eprintf (sd, "Simulator cache profiling not compiled in, `--profile-simcache' ignored\n");
 477       else
 478         {
 479           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 480             CPU_PROFILE_FLAGS (STATE_CPU (sd, n))[PROFILE_SIMCACHE_IDX] = 1;
 481         }
 482       break;
 483
 484     case OPTION_PROFILE_FILE :
 485       /* FIXME: Might want this to apply to pc profiling only,
 486          or have two profile file options.  */
 487       if (! WITH_PROFILE)
 488         sim_io_eprintf (sd, "Profiling not compiled in, `--profile-file' ignored\n");
 489       else
 490         {
 491           FILE *f = fopen (arg, "w");
 492
 493           if (f == NULL)
 494             {
 495               sim_io_eprintf (sd, "Unable to open profile output file `%s'\n", arg);
 496               return SIM_RC_FAIL;
 497             }
 498           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 499             CPU_PROFILE_FILE (STATE_CPU (sd, n)) = f;
 500         }
 501       break;
 502
 503 #ifdef SIM_HAVE_PROFILE_PC
 504     case 'F' :
 505       STATE_PROFILE_PC_FREQUENCY (sd) = atoi (arg);
 506       /* FIXME: Validate arg.  */
 507       break;
 508     case 'S' :
 509       STATE_PROFILE_PC_SIZE (sd) = atoi (arg);
 510       /* FIXME: Validate arg.  */
 511       break;
 512 #endif
 513 #endif /* SIM_HAVE_PROFILE */
 514
 515     case 'H':
 516       sim_print_help (sd);
 517       if (STATE_OPEN_KIND (sd) == SIM_OPEN_STANDALONE)
 518         exit (0);
 519       /* FIXME: 'twould be nice to do something similar if gdb.  */
 520       break;
 521     }
 522
 523   return SIM_RC_OK;
 524 }
 525
 526 /* Initialize common parts before argument processing.
 527    Called by sim_open.  */
 528
 529 SIM_RC
 530 sim_pre_argv_init (sd, myname)
 531      SIM_DESC sd;
 532      const char *myname;
 533 {
 534   STATE_MY_NAME (sd) = myname + strlen (myname);
 535   while (STATE_MY_NAME (sd) > myname && STATE_MY_NAME (sd)[-1] != '/')
 536     --STATE_MY_NAME (sd);
 537
 538   if (sim_add_option_table (sd, standard_options) != SIM_RC_OK)
 539     return SIM_RC_FAIL;
 540
 541   return SIM_RC_OK;
 542 }
 543
 544 /* Return non-zero if arg is a duplicate argument.
 545    If ARG is NULL, initialize.  */
 546
 547 #define ARG_HASH_SIZE 97
 548 #define ARG_HASH(a) ((256 * (unsigned char) a[0] + (unsigned char) a[1]) % ARG_HASH_SIZE)
 549
 550 static int
 551 dup_arg_p (arg)
 552      char *arg;
 553 {
 554   int hash;
 555   static char **arg_table = NULL;
 556
 557   if (arg == NULL)
 558     {
 559       if (arg_table == NULL)
 560         arg_table = (char **) xmalloc (ARG_HASH_SIZE * sizeof (char *));
 561       memset (arg_table, 0, ARG_HASH_SIZE * sizeof (char *));
 562       return 0;
 563     }
 564
 565   hash = ARG_HASH (arg);
 566   while (arg_table[hash] != NULL)
 567     {
 568       if (strcmp (arg, arg_table[hash]) == 0)
 569         return 1;
 570       /* We assume there won't be more than ARG_HASH_SIZE arguments so we
 571          don't check if the table is full.  */
 572       if (++hash == ARG_HASH_SIZE)
 573         hash = 0;
 574     }
 575   arg_table[hash] = arg;
 576   return 0;
 577 }
 578
 579 /* Called by sim_open to parse the arguments.  */
 580
 581 SIM_RC
 582 sim_parse_args (sd, argv)
 583      SIM_DESC sd;
 584      char **argv;
 585 {
 586   int i, argc, num_opts;
 587   char *p, *short_options;
 588   /* The `val' option struct entry is dynamically assigned for options that
 589      only come in the long form.  ORIG_VAL is used to get the original value
 590      back.  */
 591   unsigned char *orig_val;
 592   struct option *lp, *long_options;
 593   const struct option_list *ol;
 594   const OPTION *opt;
 595   OPTION_HANDLER **handlers;
 596
 597   /* Count the number of arguments.  */
 598   for (argc = 0; argv[argc] != NULL; ++argc)
 599     continue;
 600
 601   /* Count the number of options.  */
 602   num_opts = 0;
 603   for (ol = STATE_OPTIONS (sd); ol != NULL; ol = ol->next)
 604     for (opt = ol->options; opt->opt.name != NULL; ++opt)
 605       ++num_opts;
 606
 607   /* Initialize duplicate argument checker.  */
 608   (void) dup_arg_p (NULL);
 609
 610   /* Build the option table for getopt.  */
 611   long_options = (struct option *) alloca ((num_opts + 1) * sizeof (struct option));
 612   lp = long_options;
 613   short_options = (char *) alloca (num_opts * 3 + 1);
 614   p = short_options;
 615 #if 0 /* ??? necessary anymore? */
 616   /* Set '+' as first char so argument permutation isn't done.  This is done
 617      to workaround a problem with invoking getopt_long in run.c.: optind gets
 618      decremented when the program name is reached.  */
 619   *p++ = '+';
 620 #endif
 621   handlers = (OPTION_HANDLER **) alloca (256 * sizeof (OPTION_HANDLER *));
 622   memset (handlers, 0, 256 * sizeof (OPTION_HANDLER *));
 623   orig_val = (unsigned char *) alloca (256);
 624   for (i = OPTION_START, ol = STATE_OPTIONS (sd); ol != NULL; ol = ol->next)
 625     for (opt = ol->options; opt->opt.name != NULL; ++opt)
 626       {
 627         if (dup_arg_p (opt->opt.name))
 628           continue;
 629         if (opt->shortopt != 0)
 630           {
 631             *p++ = opt->shortopt;
 632             if (opt->opt.has_arg == required_argument)
 633               *p++ = ':';
 634             else if (opt->opt.has_arg == optional_argument)
 635               { *p++ = ':'; *p++ = ':'; }
 636           }
 637         *lp = opt->opt;
 638         /* Dynamically assign `val' numbers for long options that don't have
 639            a short option equivalent.  */
 640         if (OPTION_LONG_ONLY_P (opt->opt.val))
 641           lp->val = i++;
 642         handlers[(unsigned char) lp->val] = opt->handler;
 643         orig_val[(unsigned char) lp->val] = opt->opt.val;
 644         ++lp;
 645       }
 646   *p = 0;
 647   lp->name = NULL;
 648
 649   /* Ensure getopt is initialized.  */
 650   optind = 0;
 651   while (1)
 652     {
 653       int longind, optc;
 654
 655       optc = getopt_long (argc, argv, short_options, long_options, &longind);
 656       if (optc == -1)
 657         {
 658           if (STATE_OPEN_KIND (sd) == SIM_OPEN_STANDALONE)
 659             STATE_PROG_ARGV (sd) = argv + optind;
 660           break;
 661         }
 662       if (optc == '?')
 663         return SIM_RC_FAIL;
 664
 665       if ((*handlers[optc]) (sd, orig_val[optc], optarg) == SIM_RC_FAIL)
 666         return SIM_RC_FAIL;
 667     }
 668
 669   return SIM_RC_OK;
 670 }
 671
 672 /* Print help messages for the options.  */
 673
 674 void
 675 sim_print_help (sd)
 676      SIM_DESC sd;
 677 {
 678   const struct option_list *ol;
 679   const OPTION *opt;
 680
 681   if (STATE_OPEN_KIND (sd) == SIM_OPEN_STANDALONE)
 682     sim_io_printf (sd, "Usage: %s [options] program [program args]\n",
 683                    STATE_MY_NAME (sd));
 684
 685   /* Initialize duplicate argument checker.  */
 686   (void) dup_arg_p (NULL);
 687
 688   sim_io_printf (sd, "Options:\n");
 689   for (ol = STATE_OPTIONS (sd); ol != NULL; ol = ol->next)
 690     for (opt = ol->options; opt->opt.name != NULL; ++opt)
 691       {
 692         int comma, len;
 693         const OPTION *o;
 694
 695         if (dup_arg_p (opt->opt.name))
 696           continue;
 697
 698         if (opt->doc == NULL)
 699           continue;
 700
 701         sim_io_printf (sd, "  ");
 702
 703         comma = 0;
 704         len = 2;
 705
 706         o = opt;
 707         do
 708           {
 709             if (o->shortopt != '\0')
 710               {
 711                 sim_io_printf (sd, "%s-%c", comma ? ", " : "", o->shortopt);
 712                 len += (comma ? 2 : 0) + 2;
 713                 if (o->arg != NULL)
 714                   {
 715                     if (o->opt.has_arg != optional_argument)
 716                       {
 717                         sim_io_printf (sd, " ");
 718                         ++len;
 719                       }
 720                     sim_io_printf (sd, "%s", o->arg);
 721                     len += strlen (o->arg);
 722                   }
 723                 comma = 1;
 724               }
 725             ++o;
 726           }
 727         while (o->opt.name != NULL && o->doc == NULL);
 728
 729         o = opt;
 730         do
 731           {
 732             if (o->opt.name != NULL)
 733               {
 734                 sim_io_printf (sd, "%s--%s",
 735                                comma ? ", " : "",
 736                                o->opt.name);
 737                 len += ((comma ? 2 : 0)
 738                         + 2
 739                         + strlen (o->opt.name));
 740                 if (o->arg != NULL)
 741                   {
 742                     sim_io_printf (sd, " %s", o->arg);
 743                     len += 1 + strlen (o->arg);
 744                   }
 745                 comma = 1;
 746               }
 747             ++o;
 748           }
 749         while (o->opt.name != NULL && o->doc == NULL);
 750
 751         if (len >= 30)
 752           {
 753             sim_io_printf (sd, "\n");
 754             len = 0;
 755           }
 756
 757         for (; len < 30; len++)
 758           sim_io_printf (sd, " ");
 759
 760         sim_io_printf (sd, "%s\n", opt->doc);
 761       }
 762
 763   if (STATE_OPEN_KIND (sd) == SIM_OPEN_STANDALONE)
 764     {
 765       sim_io_printf (sd, "\n");
 766       sim_io_printf (sd, "program args    Arguments to pass to simulated program.\n");
 767       sim_io_printf (sd, "                Note: Very few simulators support this.\n");
 768     }
 769 }