sim/common/sim-options.c

   1 /* Simulator option handling.
   2    Copyright (C) 1996, 1997, 2004, 2007 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 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 #include "sim-main.h"
  21 #ifdef HAVE_STRING_H
  22 #include <string.h>
  23 #else
  24 #ifdef HAVE_STRINGS_H
  25 #include <strings.h>
  26 #endif
  27 #endif
  28 #ifdef HAVE_STDLIB_H
  29 #include <stdlib.h>
  30 #endif
  31 #include <ctype.h>
  32 #include "libiberty.h"
  33 #include "sim-options.h"
  34 #include "sim-io.h"
  35 #include "sim-assert.h"
  36
  37 #include "bfd.h"
  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 (SIM_DESC sd, sim_cpu *cpu, const OPTION *table)
  45 {
  46   struct option_list *ol = ((struct option_list *)
  47                             xmalloc (sizeof (struct option_list)));
  48
  49   /* Note: The list is constructed in the reverse order we're called so
  50      later calls will override earlier ones (in case that ever happens).
  51      This is the intended behaviour.  */
  52
  53   if (cpu)
  54     {
  55       ol->next = CPU_OPTIONS (cpu);
  56       ol->options = table;
  57       CPU_OPTIONS (cpu) = ol;
  58     }
  59   else
  60     {
  61       ol->next = STATE_OPTIONS (sd);
  62       ol->options = table;
  63       STATE_OPTIONS (sd) = ol;
  64     }
  65
  66   return SIM_RC_OK;
  67 }
  68
  69 /* Standard option table.
  70    Modules may specify additional ones.
  71    The caller of sim_parse_args may also specify additional options
  72    by calling sim_add_option_table first.  */
  73
  74 static DECLARE_OPTION_HANDLER (standard_option_handler);
  75
  76 /* FIXME: We shouldn't print in --help output options that aren't usable.
  77    Some fine tuning will be necessary.  One can either move less general
  78    options to another table or use a HAVE_FOO macro to ifdef out unavailable
  79    options.  */
  80
  81 /* ??? One might want to conditionally compile out the entries that
  82    aren't enabled.  There's a distinction, however, between options a
  83    simulator can't support and options that haven't been configured in.
  84    Certainly options a simulator can't support shouldn't appear in the
  85    output of --help.  Whether the same thing applies to options that haven't
  86    been configured in or not isn't something I can get worked up over.
  87    [Note that conditionally compiling them out might simply involve moving
  88    the option to another table.]
  89    If you decide to conditionally compile them out as well, delete this
  90    comment and add a comment saying that that is the rule.  */
  91
  92 typedef enum {
  93   OPTION_DEBUG_INSN = OPTION_START,
  94   OPTION_DEBUG_FILE,
  95   OPTION_DO_COMMAND,
  96   OPTION_ARCHITECTURE,
  97   OPTION_TARGET,
  98   OPTION_ARCHITECTURE_INFO,
  99   OPTION_ENVIRONMENT,
 100   OPTION_ALIGNMENT,
 101   OPTION_VERBOSE,
 102 #if defined (SIM_HAVE_BIENDIAN)
 103   OPTION_ENDIAN,
 104 #endif
 105   OPTION_DEBUG,
 106 #ifdef SIM_HAVE_FLATMEM
 107   OPTION_MEM_SIZE,
 108 #endif
 109   OPTION_HELP,
 110 #ifdef SIM_H8300 /* FIXME: Should be movable to h8300 dir.  */
 111   OPTION_H8300H,
 112   OPTION_H8300S,
 113   OPTION_H8300SX,
 114 #endif
 115   OPTION_LOAD_LMA,
 116   OPTION_LOAD_VMA,
 117   OPTION_SYSROOT
 118 } STANDARD_OPTIONS;
 119
 120 static const OPTION standard_options[] =
 121 {
 122   { {"verbose", no_argument, NULL, OPTION_VERBOSE},
 123       'v', NULL, "Verbose output",
 124       standard_option_handler },
 125
 126 #if defined (SIM_HAVE_BIENDIAN) /* ??? && WITH_TARGET_BYTE_ORDER == 0 */
 127   { {"endian", required_argument, NULL, OPTION_ENDIAN},
 128       'E', "big|little", "Set endianness",
 129       standard_option_handler },
 130 #endif
 131
 132 #ifdef SIM_HAVE_ENVIRONMENT
 133   /* This option isn't supported unless all choices are supported in keeping
 134      with the goal of not printing in --help output things the simulator can't
 135      do [as opposed to things that just haven't been configured in].  */
 136   { {"environment", required_argument, NULL, OPTION_ENVIRONMENT},
 137       '\0', "user|virtual|operating", "Set running environment",
 138       standard_option_handler },
 139 #endif
 140
 141   { {"alignment", required_argument, NULL, OPTION_ALIGNMENT},
 142       '\0', "strict|nonstrict|forced", "Set memory access alignment",
 143       standard_option_handler },
 144
 145   { {"debug", no_argument, NULL, OPTION_DEBUG},
 146       'D', NULL, "Print debugging messages",
 147       standard_option_handler },
 148   { {"debug-insn", no_argument, NULL, OPTION_DEBUG_INSN},
 149       '\0', NULL, "Print instruction debugging messages",
 150       standard_option_handler },
 151   { {"debug-file", required_argument, NULL, OPTION_DEBUG_FILE},
 152       '\0', "FILE NAME", "Specify debugging output file",
 153       standard_option_handler },
 154
 155 #ifdef SIM_H8300 /* FIXME: Should be movable to h8300 dir.  */
 156   { {"h8300h", no_argument, NULL, OPTION_H8300H},
 157       'h', NULL, "Indicate the CPU is H8/300H",
 158       standard_option_handler },
 159   { {"h8300s", no_argument, NULL, OPTION_H8300S},
 160       'S', NULL, "Indicate the CPU is H8S",
 161       standard_option_handler },
 162   { {"h8300sx", no_argument, NULL, OPTION_H8300SX},
 163       'x', NULL, "Indicate the CPU is H8SX",
 164       standard_option_handler },
 165 #endif
 166
 167 #ifdef SIM_HAVE_FLATMEM
 168   { {"mem-size", required_argument, NULL, OPTION_MEM_SIZE},
 169      'm', "<size>[in bytes, Kb (k suffix), Mb (m suffix) or Gb (g suffix)]",
 170      "Specify memory size", standard_option_handler },
 171 #endif
 172
 173   { {"do-command", required_argument, NULL, OPTION_DO_COMMAND},
 174       '\0', "COMMAND", ""/*undocumented*/,
 175       standard_option_handler },
 176
 177   { {"help", no_argument, NULL, OPTION_HELP},
 178       'H', NULL, "Print help information",
 179       standard_option_handler },
 180
 181   { {"architecture", required_argument, NULL, OPTION_ARCHITECTURE},
 182       '\0', "MACHINE", "Specify the architecture to use",
 183       standard_option_handler },
 184   { {"architecture-info", no_argument, NULL, OPTION_ARCHITECTURE_INFO},
 185       '\0', NULL, "List supported architectures",
 186       standard_option_handler },
 187   { {"info-architecture", no_argument, NULL, OPTION_ARCHITECTURE_INFO},
 188       '\0', NULL, NULL,
 189       standard_option_handler },
 190
 191   { {"target", required_argument, NULL, OPTION_TARGET},
 192       '\0', "BFDNAME", "Specify the object-code format for the object files",
 193       standard_option_handler },
 194
 195 #ifdef SIM_HANDLES_LMA
 196   { {"load-lma", no_argument, NULL, OPTION_LOAD_LMA},
 197       '\0', NULL,
 198 #if SIM_HANDLES_LMA
 199     "Use VMA or LMA addresses when loading image (default LMA)",
 200 #else
 201     "Use VMA or LMA addresses when loading image (default VMA)",
 202 #endif
 203       standard_option_handler, "load-{lma,vma}" },
 204   { {"load-vma", no_argument, NULL, OPTION_LOAD_VMA},
 205       '\0', NULL, "", standard_option_handler,  "" },
 206 #endif
 207
 208   { {"sysroot", required_argument, NULL, OPTION_SYSROOT},
 209       '\0', "SYSROOT",
 210     "Root for system calls with absolute file-names and cwd at start",
 211       standard_option_handler },
 212
 213   { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL }
 214 };
 215
 216 static SIM_RC
 217 standard_option_handler (SIM_DESC sd, sim_cpu *cpu, int opt,
 218                          char *arg, int is_command)
 219 {
 220   int i,n;
 221
 222   switch ((STANDARD_OPTIONS) opt)
 223     {
 224     case OPTION_VERBOSE:
 225       STATE_VERBOSE_P (sd) = 1;
 226       break;
 227
 228 #ifdef SIM_HAVE_BIENDIAN
 229     case OPTION_ENDIAN:
 230       if (strcmp (arg, "big") == 0)
 231         {
 232           if (WITH_TARGET_BYTE_ORDER == LITTLE_ENDIAN)
 233             {
 234               sim_io_eprintf (sd, "Simulator compiled for little endian only.\n");
 235               return SIM_RC_FAIL;
 236             }
 237           /* FIXME:wip: Need to set something in STATE_CONFIG.  */
 238           current_target_byte_order = BIG_ENDIAN;
 239         }
 240       else if (strcmp (arg, "little") == 0)
 241         {
 242           if (WITH_TARGET_BYTE_ORDER == BIG_ENDIAN)
 243             {
 244               sim_io_eprintf (sd, "Simulator compiled for big endian only.\n");
 245               return SIM_RC_FAIL;
 246             }
 247           /* FIXME:wip: Need to set something in STATE_CONFIG.  */
 248           current_target_byte_order = LITTLE_ENDIAN;
 249         }
 250       else
 251         {
 252           sim_io_eprintf (sd, "Invalid endian specification `%s'\n", arg);
 253           return SIM_RC_FAIL;
 254         }
 255       break;
 256 #endif
 257
 258     case OPTION_ENVIRONMENT:
 259       if (strcmp (arg, "user") == 0)
 260         STATE_ENVIRONMENT (sd) = USER_ENVIRONMENT;
 261       else if (strcmp (arg, "virtual") == 0)
 262         STATE_ENVIRONMENT (sd) = VIRTUAL_ENVIRONMENT;
 263       else if (strcmp (arg, "operating") == 0)
 264         STATE_ENVIRONMENT (sd) = OPERATING_ENVIRONMENT;
 265       else
 266         {
 267           sim_io_eprintf (sd, "Invalid environment specification `%s'\n", arg);
 268           return SIM_RC_FAIL;
 269         }
 270       if (WITH_ENVIRONMENT != ALL_ENVIRONMENT
 271           && WITH_ENVIRONMENT != STATE_ENVIRONMENT (sd))
 272         {
 273           char *type;
 274           switch (WITH_ENVIRONMENT)
 275             {
 276             case USER_ENVIRONMENT: type = "user"; break;
 277             case VIRTUAL_ENVIRONMENT: type = "virtual"; break;
 278             case OPERATING_ENVIRONMENT: type = "operating"; break;
 279             }
 280           sim_io_eprintf (sd, "Simulator compiled for the %s environment only.\n",
 281                           type);
 282           return SIM_RC_FAIL;
 283         }
 284       break;
 285
 286     case OPTION_ALIGNMENT:
 287       if (strcmp (arg, "strict") == 0)
 288         {
 289           if (WITH_ALIGNMENT == 0 || WITH_ALIGNMENT == STRICT_ALIGNMENT)
 290             {
 291               current_alignment = STRICT_ALIGNMENT;
 292               break;
 293             }
 294         }
 295       else if (strcmp (arg, "nonstrict") == 0)
 296         {
 297           if (WITH_ALIGNMENT == 0 || WITH_ALIGNMENT == NONSTRICT_ALIGNMENT)
 298             {
 299               current_alignment = NONSTRICT_ALIGNMENT;
 300               break;
 301             }
 302         }
 303       else if (strcmp (arg, "forced") == 0)
 304         {
 305           if (WITH_ALIGNMENT == 0 || WITH_ALIGNMENT == FORCED_ALIGNMENT)
 306             {
 307               current_alignment = FORCED_ALIGNMENT;
 308               break;
 309             }
 310         }
 311       else
 312         {
 313           sim_io_eprintf (sd, "Invalid alignment specification `%s'\n", arg);
 314           return SIM_RC_FAIL;
 315         }
 316       switch (WITH_ALIGNMENT)
 317         {
 318         case STRICT_ALIGNMENT:
 319           sim_io_eprintf (sd, "Simulator compiled for strict alignment only.\n");
 320           break;
 321         case NONSTRICT_ALIGNMENT:
 322           sim_io_eprintf (sd, "Simulator compiled for nonstrict alignment only.\n");
 323           break;
 324         case FORCED_ALIGNMENT:
 325           sim_io_eprintf (sd, "Simulator compiled for forced alignment only.\n");
 326           break;
 327         }
 328       return SIM_RC_FAIL;
 329
 330     case OPTION_DEBUG:
 331       if (! WITH_DEBUG)
 332         sim_io_eprintf (sd, "Debugging not compiled in, `-D' ignored\n");
 333       else
 334         {
 335           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 336             for (i = 0; i < MAX_DEBUG_VALUES; ++i)
 337               CPU_DEBUG_FLAGS (STATE_CPU (sd, n))[i] = 1;
 338         }
 339       break;
 340
 341     case OPTION_DEBUG_INSN :
 342       if (! WITH_DEBUG)
 343         sim_io_eprintf (sd, "Debugging not compiled in, `--debug-insn' ignored\n");
 344       else
 345         {
 346           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 347             CPU_DEBUG_FLAGS (STATE_CPU (sd, n))[DEBUG_INSN_IDX] = 1;
 348         }
 349       break;
 350
 351     case OPTION_DEBUG_FILE :
 352       if (! WITH_DEBUG)
 353         sim_io_eprintf (sd, "Debugging not compiled in, `--debug-file' ignored\n");
 354       else
 355         {
 356           FILE *f = fopen (arg, "w");
 357
 358           if (f == NULL)
 359             {
 360               sim_io_eprintf (sd, "Unable to open debug output file `%s'\n", arg);
 361               return SIM_RC_FAIL;
 362             }
 363           for (n = 0; n < MAX_NR_PROCESSORS; ++n)
 364             CPU_DEBUG_FILE (STATE_CPU (sd, n)) = f;
 365         }
 366       break;
 367
 368 #ifdef SIM_H8300 /* FIXME: Can be moved to h8300 dir.  */
 369     case OPTION_H8300H:
 370       set_h8300h (bfd_mach_h8300h);
 371       break;
 372     case OPTION_H8300S:
 373       set_h8300h (bfd_mach_h8300s);
 374       break;
 375     case OPTION_H8300SX:
 376       set_h8300h (bfd_mach_h8300sx);
 377       break;
 378 #endif
 379
 380 #ifdef SIM_HAVE_FLATMEM
 381     case OPTION_MEM_SIZE:
 382       {
 383         char * endp;
 384         unsigned long ul = strtol (arg, &endp, 0);
 385
 386         switch (* endp)
 387           {
 388           case 'k': case 'K': size <<= 10; break;
 389           case 'm': case 'M': size <<= 20; break;
 390           case 'g': case 'G': size <<= 30; break;
 391           case ' ': case '\0': case '\t':  break;
 392           default:
 393             if (ul > 0)
 394               sim_io_eprintf (sd, "Ignoring strange character at end of memory size: %c\n", * endp);
 395             break;
 396           }
 397
 398         /* 16384: some minimal amount */
 399         if (! isdigit (arg[0]) || ul < 16384)
 400           {
 401             sim_io_eprintf (sd, "Invalid memory size `%s'", arg);
 402             return SIM_RC_FAIL;
 403           }
 404         STATE_MEM_SIZE (sd) = ul;
 405       }
 406       break;
 407 #endif
 408
 409     case OPTION_DO_COMMAND:
 410       sim_do_command (sd, arg);
 411       break;
 412
 413     case OPTION_ARCHITECTURE:
 414       {
 415         const struct bfd_arch_info *ap = bfd_scan_arch (arg);
 416         if (ap == NULL)
 417           {
 418             sim_io_eprintf (sd, "Architecture `%s' unknown\n", arg);
 419             return SIM_RC_FAIL;
 420           }
 421         STATE_ARCHITECTURE (sd) = ap;
 422         break;
 423       }
 424
 425     case OPTION_ARCHITECTURE_INFO:
 426       {
 427         const char **list = bfd_arch_list();
 428         const char **lp;
 429         if (list == NULL)
 430           abort ();
 431         sim_io_printf (sd, "Possible architectures:");
 432         for (lp = list; *lp != NULL; lp++)
 433           sim_io_printf (sd, " %s", *lp);
 434         sim_io_printf (sd, "\n");
 435         free (list);
 436         break;
 437       }
 438
 439     case OPTION_TARGET:
 440       {
 441         STATE_TARGET (sd) = xstrdup (arg);
 442         break;
 443       }
 444
 445     case OPTION_LOAD_LMA:
 446       {
 447         STATE_LOAD_AT_LMA_P (sd) = 1;
 448         break;
 449       }
 450
 451     case OPTION_LOAD_VMA:
 452       {
 453         STATE_LOAD_AT_LMA_P (sd) = 0;
 454         break;
 455       }
 456
 457     case OPTION_HELP:
 458       sim_print_help (sd, is_command);
 459       if (STATE_OPEN_KIND (sd) == SIM_OPEN_STANDALONE)
 460         exit (0);
 461       /* FIXME: 'twould be nice to do something similar if gdb.  */
 462       break;
 463
 464     case OPTION_SYSROOT:
 465       /* Don't leak memory in the odd event that there's lots of
 466          --sysroot=... options.  */
 467       if (simulator_sysroot[0] != '\0' && arg[0] != '\0')
 468         free (simulator_sysroot);
 469       simulator_sysroot = xstrdup (arg);
 470       break;
 471     }
 472
 473   return SIM_RC_OK;
 474 }
 475
 476 /* Add the standard option list to the simulator.  */
 477
 478 SIM_RC
 479 standard_install (SIM_DESC sd)
 480 {
 481   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 482   if (sim_add_option_table (sd, NULL, standard_options) != SIM_RC_OK)
 483     return SIM_RC_FAIL;
 484 #ifdef SIM_HANDLES_LMA
 485   STATE_LOAD_AT_LMA_P (sd) = SIM_HANDLES_LMA;
 486 #endif
 487   return SIM_RC_OK;
 488 }
 489
 490 /* Return non-zero if arg is a duplicate argument.
 491    If ARG is NULL, initialize.  */
 492
 493 #define ARG_HASH_SIZE 97
 494 #define ARG_HASH(a) ((256 * (unsigned char) a[0] + (unsigned char) a[1]) % ARG_HASH_SIZE)
 495
 496 static int
 497 dup_arg_p (arg)
 498      char *arg;
 499 {
 500   int hash;
 501   static char **arg_table = NULL;
 502
 503   if (arg == NULL)
 504     {
 505       if (arg_table == NULL)
 506         arg_table = (char **) xmalloc (ARG_HASH_SIZE * sizeof (char *));
 507       memset (arg_table, 0, ARG_HASH_SIZE * sizeof (char *));
 508       return 0;
 509     }
 510
 511   hash = ARG_HASH (arg);
 512   while (arg_table[hash] != NULL)
 513     {
 514       if (strcmp (arg, arg_table[hash]) == 0)
 515         return 1;
 516       /* We assume there won't be more than ARG_HASH_SIZE arguments so we
 517          don't check if the table is full.  */
 518       if (++hash == ARG_HASH_SIZE)
 519         hash = 0;
 520     }
 521   arg_table[hash] = arg;
 522   return 0;
 523 }
 524
 525 /* Called by sim_open to parse the arguments.  */
 526
 527 SIM_RC
 528 sim_parse_args (sd, argv)
 529      SIM_DESC sd;
 530      char **argv;
 531 {
 532   int c, i, argc, num_opts;
 533   char *p, *short_options;
 534   /* The `val' option struct entry is dynamically assigned for options that
 535      only come in the long form.  ORIG_VAL is used to get the original value
 536      back.  */
 537   int *orig_val;
 538   struct option *lp, *long_options;
 539   const struct option_list *ol;
 540   const OPTION *opt;
 541   OPTION_HANDLER **handlers;
 542   sim_cpu **opt_cpu;
 543   SIM_RC result = SIM_RC_OK;
 544
 545   /* Count the number of arguments.  */
 546   for (argc = 0; argv[argc] != NULL; ++argc)
 547     continue;
 548
 549   /* Count the number of options.  */
 550   num_opts = 0;
 551   for (ol = STATE_OPTIONS (sd); ol != NULL; ol = ol->next)
 552     for (opt = ol->options; OPTION_VALID_P (opt); ++opt)
 553       ++num_opts;
 554   for (i = 0; i < MAX_NR_PROCESSORS; ++i)
 555     for (ol = CPU_OPTIONS (STATE_CPU (sd, i)); ol != NULL; ol = ol->next)
 556       for (opt = ol->options; OPTION_VALID_P (opt); ++opt)
 557         ++num_opts;
 558
 559   /* Initialize duplicate argument checker.  */
 560   (void) dup_arg_p (NULL);
 561
 562   /* Build the option table for getopt.  */
 563
 564   long_options = NZALLOC (struct option, num_opts + 1);
 565   lp = long_options;
 566   short_options = NZALLOC (char, num_opts * 3 + 1);
 567   p = short_options;
 568   handlers = NZALLOC (OPTION_HANDLER *, OPTION_START + num_opts);
 569   orig_val = NZALLOC (int, OPTION_START + num_opts);
 570   opt_cpu = NZALLOC (sim_cpu *, OPTION_START + num_opts);
 571
 572   /* Set '+' as first char so argument permutation isn't done.  This
 573      is done to stop getopt_long returning options that appear after
 574      the target program.  Such options should be passed unchanged into
 575      the program image. */
 576   *p++ = '+';
 577
 578   for (i = OPTION_START, ol = STATE_OPTIONS (sd); ol != NULL; ol = ol->next)
 579     for (opt = ol->options; OPTION_VALID_P (opt); ++opt)
 580       {
 581         if (dup_arg_p (opt->opt.name))
 582           continue;
 583         if (opt->shortopt != 0)
 584           {
 585             *p++ = opt->shortopt;
 586             if (opt->opt.has_arg == required_argument)
 587               *p++ = ':';
 588             else if (opt->opt.has_arg == optional_argument)
 589               { *p++ = ':'; *p++ = ':'; }
 590             handlers[(unsigned char) opt->shortopt] = opt->handler;
 591             if (opt->opt.val != 0)
 592               orig_val[(unsigned char) opt->shortopt] = opt->opt.val;
 593             else
 594               orig_val[(unsigned char) opt->shortopt] = opt->shortopt;
 595           }
 596         if (opt->opt.name != NULL)
 597           {
 598             *lp = opt->opt;
 599             /* Dynamically assign `val' numbers for long options. */
 600             lp->val = i++;
 601             handlers[lp->val] = opt->handler;
 602             orig_val[lp->val] = opt->opt.val;
 603             opt_cpu[lp->val] = NULL;
 604             ++lp;
 605           }
 606       }
 607
 608   for (c = 0; c < MAX_NR_PROCESSORS; ++c)
 609     {
 610       sim_cpu *cpu = STATE_CPU (sd, c);
 611       for (ol = CPU_OPTIONS (cpu); ol != NULL; ol = ol->next)
 612         for (opt = ol->options; OPTION_VALID_P (opt); ++opt)
 613           {
 614 #if 0 /* Each option is prepended with --<cpuname>- so this greatly cuts down
 615          on the need for dup_arg_p checking.  Maybe in the future it'll be
 616          needed so this is just commented out, and not deleted.  */
 617             if (dup_arg_p (opt->opt.name))
 618               continue;
 619 #endif
 620             /* Don't allow short versions of cpu specific options for now.  */
 621             if (opt->shortopt != 0)
 622               {
 623                 sim_io_eprintf (sd, "internal error, short cpu specific option");
 624                 result = SIM_RC_FAIL;
 625                 break;
 626               }
 627             if (opt->opt.name != NULL)
 628               {
 629                 char *name;
 630                 *lp = opt->opt;
 631                 /* Prepend --<cpuname>- to the option.  */
 632                 asprintf (&name, "%s-%s", CPU_NAME (cpu), lp->name);
 633                 lp->name = name;
 634                 /* Dynamically assign `val' numbers for long options. */
 635                 lp->val = i++;
 636                 handlers[lp->val] = opt->handler;
 637                 orig_val[lp->val] = opt->opt.val;
 638                 opt_cpu[lp->val] = cpu;
 639                 ++lp;
 640               }
 641           }
 642     }
 643
 644   /* Terminate the short and long option lists.  */
 645   *p = 0;
 646   lp->name = NULL;
 647
 648   /* Ensure getopt is initialized.  */
 649   optind = 0;
 650
 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) = dupargv (argv + optind);
 660           break;
 661         }
 662       if (optc == '?')
 663         {
 664           result = SIM_RC_FAIL;
 665           break;
 666         }
 667
 668       if ((*handlers[optc]) (sd, opt_cpu[optc], orig_val[optc], optarg, 0/*!is_command*/) == SIM_RC_FAIL)
 669         {
 670           result = SIM_RC_FAIL;
 671           break;
 672         }
 673     }
 674
 675   zfree (long_options);
 676   zfree (short_options);
 677   zfree (handlers);
 678   zfree (opt_cpu);
 679   zfree (orig_val);
 680   return result;
 681 }
 682
 683 /* Utility of sim_print_help to print a list of option tables.  */
 684
 685 static void
 686 print_help (SIM_DESC sd, sim_cpu *cpu, const struct option_list *ol, int is_command)
 687 {
 688   const OPTION *opt;
 689
 690   for ( ; ol != NULL; ol = ol->next)
 691     for (opt = ol->options; OPTION_VALID_P (opt); ++opt)
 692       {
 693         const int indent = 30;
 694         int comma, len;
 695         const OPTION *o;
 696
 697         if (dup_arg_p (opt->opt.name))
 698           continue;
 699
 700         if (opt->doc == NULL)
 701           continue;
 702
 703         if (opt->doc_name != NULL && opt->doc_name [0] == '\0')
 704           continue;
 705
 706         sim_io_printf (sd, "  ");
 707
 708         comma = 0;
 709         len = 2;
 710
 711         /* list any short options (aliases) for the current OPT */
 712         if (!is_command)
 713           {
 714             o = opt;
 715             do
 716               {
 717                 if (o->shortopt != '\0')
 718                   {
 719                     sim_io_printf (sd, "%s-%c", comma ? ", " : "", o->shortopt);
 720                     len += (comma ? 2 : 0) + 2;
 721                     if (o->arg != NULL)
 722                       {
 723                         if (o->opt.has_arg == optional_argument)
 724                           {
 725                             sim_io_printf (sd, "[%s]", o->arg);
 726                             len += 1 + strlen (o->arg) + 1;
 727                           }
 728                         else
 729                           {
 730                             sim_io_printf (sd, " %s", o->arg);
 731                             len += 1 + strlen (o->arg);
 732                           }
 733                       }
 734                     comma = 1;
 735                   }
 736                 ++o;
 737               }
 738             while (OPTION_VALID_P (o) && o->doc == NULL);
 739           }
 740
 741         /* list any long options (aliases) for the current OPT */
 742         o = opt;
 743         do
 744           {
 745             const char *name;
 746             const char *cpu_prefix = cpu ? CPU_NAME (cpu) : NULL;
 747             if (o->doc_name != NULL)
 748               name = o->doc_name;
 749             else
 750               name = o->opt.name;
 751             if (name != NULL)
 752               {
 753                 sim_io_printf (sd, "%s%s%s%s%s",
 754                                comma ? ", " : "",
 755                                is_command ? "" : "--",
 756                                cpu ? cpu_prefix : "",
 757                                cpu ? "-" : "",
 758                                name);
 759                 len += ((comma ? 2 : 0)
 760                         + (is_command ? 0 : 2)
 761                         + strlen (name));
 762                 if (o->arg != NULL)
 763                   {
 764                     if (o->opt.has_arg == optional_argument)
 765                       {
 766                         sim_io_printf (sd, "[=%s]", o->arg);
 767                         len += 2 + strlen (o->arg) + 1;
 768                       }
 769                     else
 770                       {
 771                         sim_io_printf (sd, " %s", o->arg);
 772                         len += 1 + strlen (o->arg);
 773                       }
 774                   }
 775                 comma = 1;
 776               }
 777             ++o;
 778           }
 779         while (OPTION_VALID_P (o) && o->doc == NULL);
 780
 781         if (len >= indent)
 782           {
 783             sim_io_printf (sd, "\n%*s", indent, "");
 784           }
 785         else
 786           sim_io_printf (sd, "%*s", indent - len, "");
 787
 788         /* print the description, word wrap long lines */
 789         {
 790           const char *chp = opt->doc;
 791           unsigned doc_width = 80 - indent;
 792           while (strlen (chp) >= doc_width) /* some slack */
 793             {
 794               const char *end = chp + doc_width - 1;
 795               while (end > chp && !isspace (*end))
 796                 end --;
 797               if (end == chp)
 798                 end = chp + doc_width - 1;
 799               /* The cast should be ok - its distances between to
 800                  points in a string.  */
 801               sim_io_printf (sd, "%.*s\n%*s", (int) (end - chp), chp, indent,
 802                              "");
 803               chp = end;
 804               while (isspace (*chp) && *chp != '\0')
 805                 chp++;
 806             }
 807           sim_io_printf (sd, "%s\n", chp);
 808         }
 809       }
 810 }
 811
 812 /* Print help messages for the options.  */
 813
 814 void
 815 sim_print_help (sd, is_command)
 816      SIM_DESC sd;
 817      int is_command;
 818 {
 819   if (STATE_OPEN_KIND (sd) == SIM_OPEN_STANDALONE)
 820     sim_io_printf (sd, "Usage: %s [options] program [program args]\n",
 821                    STATE_MY_NAME (sd));
 822
 823   /* Initialize duplicate argument checker.  */
 824   (void) dup_arg_p (NULL);
 825
 826   if (STATE_OPEN_KIND (sd) == SIM_OPEN_STANDALONE)
 827     sim_io_printf (sd, "Options:\n");
 828   else
 829     sim_io_printf (sd, "Commands:\n");
 830
 831   print_help (sd, NULL, STATE_OPTIONS (sd), is_command);
 832   sim_io_printf (sd, "\n");
 833
 834   /* Print cpu-specific options.  */
 835   {
 836     int i;
 837
 838     for (i = 0; i < MAX_NR_PROCESSORS; ++i)
 839       {
 840         sim_cpu *cpu = STATE_CPU (sd, i);
 841         if (CPU_OPTIONS (cpu) == NULL)
 842           continue;
 843         sim_io_printf (sd, "CPU %s specific options:\n", CPU_NAME (cpu));
 844         print_help (sd, cpu, CPU_OPTIONS (cpu), is_command);
 845         sim_io_printf (sd, "\n");
 846       }
 847   }
 848
 849   sim_io_printf (sd, "Note: Depending on the simulator configuration some %ss\n",
 850                  STATE_OPEN_KIND (sd) == SIM_OPEN_STANDALONE ? "option" : "command");
 851   sim_io_printf (sd, "      may not be applicable\n");
 852
 853   if (STATE_OPEN_KIND (sd) == SIM_OPEN_STANDALONE)
 854     {
 855       sim_io_printf (sd, "\n");
 856       sim_io_printf (sd, "program args    Arguments to pass to simulated program.\n");
 857       sim_io_printf (sd, "                Note: Very few simulators support this.\n");
 858     }
 859 }
 860
 861 /* Utility of sim_args_command to find the closest match for a command.
 862    Commands that have "-" in them can be specified as separate words.
 863    e.g. sim memory-region 0x800000,0x4000
 864    or   sim memory region 0x800000,0x4000
 865    If CPU is non-null, use its option table list, otherwise use the main one.
 866    *PARGI is where to start looking in ARGV.  It is updated to point past
 867    the found option.  */
 868
 869 static const OPTION *
 870 find_match (SIM_DESC sd, sim_cpu *cpu, char *argv[], int *pargi)
 871 {
 872   const struct option_list *ol;
 873   const OPTION *opt;
 874   /* most recent option match */
 875   const OPTION *matching_opt = NULL;
 876   int matching_argi = -1;
 877
 878   if (cpu)
 879     ol = CPU_OPTIONS (cpu);
 880   else
 881     ol = STATE_OPTIONS (sd);
 882
 883   /* Skip passed elements specified by *PARGI.  */
 884   argv += *pargi;
 885
 886   for ( ; ol != NULL; ol = ol->next)
 887     for (opt = ol->options; OPTION_VALID_P (opt); ++opt)
 888       {
 889         int argi = 0;
 890         const char *name = opt->opt.name;
 891         if (name == NULL)
 892           continue;
 893         while (argv [argi] != NULL
 894                && strncmp (name, argv [argi], strlen (argv [argi])) == 0)
 895           {
 896             name = &name [strlen (argv[argi])];
 897             if (name [0] == '-')
 898               {
 899                 /* leading match ...<a-b-c>-d-e-f - continue search */
 900                 name ++; /* skip `-' */
 901                 argi ++;
 902                 continue;
 903               }
 904             else if (name [0] == '\0')
 905               {
 906                 /* exact match ...<a-b-c-d-e-f> - better than before? */
 907                 if (argi > matching_argi)
 908                   {
 909                     matching_argi = argi;
 910                     matching_opt = opt;
 911                   }
 912                 break;
 913               }
 914             else
 915               break;
 916           }
 917       }
 918
 919   *pargi = matching_argi;
 920   return matching_opt;
 921 }
 922
 923 SIM_RC
 924 sim_args_command (SIM_DESC sd, char *cmd)
 925 {
 926   /* something to do? */
 927   if (cmd == NULL)
 928     return SIM_RC_OK; /* FIXME - perhaps help would be better */
 929
 930   if (cmd [0] == '-')
 931     {
 932       /* user specified -<opt> ... form? */
 933       char **argv = buildargv (cmd);
 934       SIM_RC rc = sim_parse_args (sd, argv);
 935       freeargv (argv);
 936       return rc;
 937     }
 938   else
 939     {
 940       char **argv = buildargv (cmd);
 941       const OPTION *matching_opt = NULL;
 942       int matching_argi;
 943       sim_cpu *cpu;
 944
 945       if (argv [0] == NULL)
 946         return SIM_RC_OK; /* FIXME - perhaps help would be better */
 947
 948       /* First check for a cpu selector.  */
 949       {
 950         char *cpu_name = xstrdup (argv[0]);
 951         char *hyphen = strchr (cpu_name, '-');
 952         if (hyphen)
 953           *hyphen = 0;
 954         cpu = sim_cpu_lookup (sd, cpu_name);
 955         if (cpu)
 956           {
 957             /* If <cpuname>-<command>, point argv[0] at <command>.  */
 958             if (hyphen)
 959               {
 960                 matching_argi = 0;
 961                 argv[0] += hyphen - cpu_name + 1;
 962               }
 963             else
 964               matching_argi = 1;
 965             matching_opt = find_match (sd, cpu, argv, &matching_argi);
 966             /* If hyphen found restore argv[0].  */
 967             if (hyphen)
 968               argv[0] -= hyphen - cpu_name + 1;
 969           }
 970         free (cpu_name);
 971       }
 972
 973       /* If that failed, try the main table.  */
 974       if (matching_opt == NULL)
 975         {
 976           matching_argi = 0;
 977           matching_opt = find_match (sd, NULL, argv, &matching_argi);
 978         }
 979
 980       if (matching_opt != NULL)
 981         {
 982           switch (matching_opt->opt.has_arg)
 983             {
 984             case no_argument:
 985               if (argv [matching_argi + 1] == NULL)
 986                 matching_opt->handler (sd, cpu, matching_opt->opt.val,
 987                                        NULL, 1/*is_command*/);
 988               else
 989                 sim_io_eprintf (sd, "Command `%s' takes no arguments\n",
 990                                 matching_opt->opt.name);
 991               break;
 992             case optional_argument:
 993               if (argv [matching_argi + 1] == NULL)
 994                 matching_opt->handler (sd, cpu, matching_opt->opt.val,
 995                                        NULL, 1/*is_command*/);
 996               else if (argv [matching_argi + 2] == NULL)
 997                 matching_opt->handler (sd, cpu, matching_opt->opt.val,
 998                                        argv [matching_argi + 1], 1/*is_command*/);
 999               else
1000                 sim_io_eprintf (sd, "Command `%s' requires no more than one argument\n",
1001                                 matching_opt->opt.name);
1002               break;
1003             case required_argument:
1004               if (argv [matching_argi + 1] == NULL)
1005                 sim_io_eprintf (sd, "Command `%s' requires an argument\n",
1006                                 matching_opt->opt.name);
1007               else if (argv [matching_argi + 2] == NULL)
1008                 matching_opt->handler (sd, cpu, matching_opt->opt.val,
1009                                        argv [matching_argi + 1], 1/*is_command*/);
1010               else
1011                 sim_io_eprintf (sd, "Command `%s' requires only one argument\n",
1012                                 matching_opt->opt.name);
1013             }
1014           freeargv (argv);
1015           return SIM_RC_OK;
1016         }
1017
1018       freeargv (argv);
1019     }
1020
1021   /* didn't find anything that remotly matched */
1022   return SIM_RC_FAIL;
1023 }