OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [sim/] [common/] [sim-options.c] - Blame information for rev 840

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Simulator option handling.
2
   Copyright (C) 1996, 1997, 2004, 2007, 2008 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
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.