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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [sim/] [common/] [sim-options.c] - Blame information for rev 438

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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