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

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gdb/] [gdb-6.8/] [gdb/] [osabi.c] - Blame information for rev 25

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 25 jlechner
/* OS ABI variant handling for GDB.
2
 
3
   Copyright (C) 2001, 2002, 2003, 2004, 2007, 2008
4
   Free Software Foundation, Inc.
5
 
6
   This file is part of GDB.
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 "defs.h"
22
 
23
#include "gdb_assert.h"
24
#include "gdb_string.h"
25
 
26
#include "osabi.h"
27
#include "arch-utils.h"
28
#include "gdbcmd.h"
29
#include "command.h"
30
 
31
#include "elf-bfd.h"
32
 
33
#ifndef GDB_OSABI_DEFAULT
34
#define GDB_OSABI_DEFAULT GDB_OSABI_UNKNOWN
35
#endif
36
 
37
/* State for the "set osabi" command.  */
38
static enum { osabi_auto, osabi_default, osabi_user } user_osabi_state;
39
static enum gdb_osabi user_selected_osabi;
40
static const char *gdb_osabi_available_names[GDB_OSABI_INVALID + 3] = {
41
  "auto",
42
  "default",
43
  "none",
44
  NULL
45
};
46
static const char *set_osabi_string;
47
 
48
/* This table matches the indices assigned to enum gdb_osabi.  Keep
49
   them in sync.  */
50
static const char * const gdb_osabi_names[] =
51
{
52
  "none",
53
 
54
  "SVR4",
55
  "GNU/Hurd",
56
  "Solaris",
57
  "OSF/1",
58
  "GNU/Linux",
59
  "FreeBSD a.out",
60
  "FreeBSD ELF",
61
  "NetBSD a.out",
62
  "NetBSD ELF",
63
  "OpenBSD ELF",
64
  "Windows CE",
65
  "DJGPP",
66
  "Irix",
67
  "Interix",
68
  "HP/UX ELF",
69
  "HP/UX SOM",
70
 
71
  "QNX Neutrino",
72
 
73
  "Cygwin",
74
  "AIX",
75
 
76
  "<invalid>"
77
};
78
 
79
const char *
80
gdbarch_osabi_name (enum gdb_osabi osabi)
81
{
82
  if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
83
    return gdb_osabi_names[osabi];
84
 
85
  return gdb_osabi_names[GDB_OSABI_INVALID];
86
}
87
 
88
/* Handler for a given architecture/OS ABI pair.  There should be only
89
   one handler for a given OS ABI each architecture family.  */
90
struct gdb_osabi_handler
91
{
92
  struct gdb_osabi_handler *next;
93
  const struct bfd_arch_info *arch_info;
94
  enum gdb_osabi osabi;
95
  void (*init_osabi)(struct gdbarch_info, struct gdbarch *);
96
};
97
 
98
static struct gdb_osabi_handler *gdb_osabi_handler_list;
99
 
100
void
101
gdbarch_register_osabi (enum bfd_architecture arch, unsigned long machine,
102
                        enum gdb_osabi osabi,
103
                        void (*init_osabi)(struct gdbarch_info,
104
                                           struct gdbarch *))
105
{
106
  struct gdb_osabi_handler **handler_p;
107
  const struct bfd_arch_info *arch_info = bfd_lookup_arch (arch, machine);
108
  const char **name_ptr;
109
 
110
  /* Registering an OS ABI handler for "unknown" is not allowed.  */
111
  if (osabi == GDB_OSABI_UNKNOWN)
112
    {
113
      internal_error
114
        (__FILE__, __LINE__,
115
         _("gdbarch_register_osabi: An attempt to register a handler for "
116
         "OS ABI \"%s\" for architecture %s was made.  The handler will "
117
         "not be registered"),
118
         gdbarch_osabi_name (osabi),
119
         bfd_printable_arch_mach (arch, machine));
120
      return;
121
    }
122
 
123
  gdb_assert (arch_info);
124
 
125
  for (handler_p = &gdb_osabi_handler_list; *handler_p != NULL;
126
       handler_p = &(*handler_p)->next)
127
    {
128
      if ((*handler_p)->arch_info == arch_info
129
          && (*handler_p)->osabi == osabi)
130
        {
131
          internal_error
132
            (__FILE__, __LINE__,
133
             _("gdbarch_register_osabi: A handler for OS ABI \"%s\" "
134
             "has already been registered for architecture %s"),
135
             gdbarch_osabi_name (osabi),
136
             arch_info->printable_name);
137
          /* If user wants to continue, override previous definition.  */
138
          (*handler_p)->init_osabi = init_osabi;
139
          return;
140
        }
141
    }
142
 
143
  (*handler_p)
144
    = (struct gdb_osabi_handler *) xmalloc (sizeof (struct gdb_osabi_handler));
145
  (*handler_p)->next = NULL;
146
  (*handler_p)->arch_info = arch_info;
147
  (*handler_p)->osabi = osabi;
148
  (*handler_p)->init_osabi = init_osabi;
149
 
150
  /* Add this OS ABI to the list of enum values for "set osabi", if it isn't
151
     already there.  */
152
  for (name_ptr = gdb_osabi_available_names; *name_ptr; name_ptr ++)
153
    {
154
      if (*name_ptr == gdbarch_osabi_name (osabi))
155
        return;
156
    }
157
  *name_ptr++ = gdbarch_osabi_name (osabi);
158
  *name_ptr = NULL;
159
}
160
 
161
 
162
/* Sniffer to find the OS ABI for a given file's architecture and flavour.
163
   It is legal to have multiple sniffers for each arch/flavour pair, to
164
   disambiguate one OS's a.out from another, for example.  The first sniffer
165
   to return something other than GDB_OSABI_UNKNOWN wins, so a sniffer should
166
   be careful to claim a file only if it knows for sure what it is.  */
167
struct gdb_osabi_sniffer
168
{
169
  struct gdb_osabi_sniffer *next;
170
  enum bfd_architecture arch;   /* bfd_arch_unknown == wildcard */
171
  enum bfd_flavour flavour;
172
  enum gdb_osabi (*sniffer)(bfd *);
173
};
174
 
175
static struct gdb_osabi_sniffer *gdb_osabi_sniffer_list;
176
 
177
void
178
gdbarch_register_osabi_sniffer (enum bfd_architecture arch,
179
                                enum bfd_flavour flavour,
180
                                enum gdb_osabi (*sniffer_fn)(bfd *))
181
{
182
  struct gdb_osabi_sniffer *sniffer;
183
 
184
  sniffer =
185
    (struct gdb_osabi_sniffer *) xmalloc (sizeof (struct gdb_osabi_sniffer));
186
  sniffer->arch = arch;
187
  sniffer->flavour = flavour;
188
  sniffer->sniffer = sniffer_fn;
189
 
190
  sniffer->next = gdb_osabi_sniffer_list;
191
  gdb_osabi_sniffer_list = sniffer;
192
}
193
 
194
 
195
enum gdb_osabi
196
gdbarch_lookup_osabi (bfd *abfd)
197
{
198
  struct gdb_osabi_sniffer *sniffer;
199
  enum gdb_osabi osabi, match;
200
  int match_specific;
201
 
202
  /* If we aren't in "auto" mode, return the specified OS ABI.  */
203
  if (user_osabi_state == osabi_user)
204
    return user_selected_osabi;
205
 
206
  /* If we don't have a binary, return the default OS ABI (if set) or
207
     unknown (otherwise).  */
208
  if (abfd == NULL)
209
    return GDB_OSABI_DEFAULT;
210
 
211
  match = GDB_OSABI_UNKNOWN;
212
  match_specific = 0;
213
 
214
  for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL;
215
       sniffer = sniffer->next)
216
    {
217
      if ((sniffer->arch == bfd_arch_unknown /* wildcard */
218
           || sniffer->arch == bfd_get_arch (abfd))
219
          && sniffer->flavour == bfd_get_flavour (abfd))
220
        {
221
          osabi = (*sniffer->sniffer) (abfd);
222
          if (osabi < GDB_OSABI_UNKNOWN || osabi >= GDB_OSABI_INVALID)
223
            {
224
              internal_error
225
                (__FILE__, __LINE__,
226
                 _("gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
227
                 "for architecture %s flavour %d"),
228
                 (int) osabi,
229
                 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
230
                 (int) bfd_get_flavour (abfd));
231
            }
232
          else if (osabi != GDB_OSABI_UNKNOWN)
233
            {
234
              /* A specific sniffer always overrides a generic sniffer.
235
                 Croak on multiple match if the two matches are of the
236
                 same class.  If the user wishes to continue, we'll use
237
                 the first match.  */
238
              if (match != GDB_OSABI_UNKNOWN)
239
                {
240
                  if ((match_specific && sniffer->arch != bfd_arch_unknown)
241
                   || (!match_specific && sniffer->arch == bfd_arch_unknown))
242
                    {
243
                      internal_error
244
                        (__FILE__, __LINE__,
245
                         _("gdbarch_lookup_osabi: multiple %sspecific OS ABI "
246
                         "match for architecture %s flavour %d: first "
247
                         "match \"%s\", second match \"%s\""),
248
                         match_specific ? "" : "non-",
249
                         bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
250
                         (int) bfd_get_flavour (abfd),
251
                         gdbarch_osabi_name (match),
252
                         gdbarch_osabi_name (osabi));
253
                    }
254
                  else if (sniffer->arch != bfd_arch_unknown)
255
                    {
256
                      match = osabi;
257
                      match_specific = 1;
258
                    }
259
                }
260
              else
261
                {
262
                  match = osabi;
263
                  if (sniffer->arch != bfd_arch_unknown)
264
                    match_specific = 1;
265
                }
266
            }
267
        }
268
    }
269
 
270
  /* If we didn't find a match, but a default was specified at configure
271
     time, return the default.  */
272
  if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN && match == GDB_OSABI_UNKNOWN)
273
    return GDB_OSABI_DEFAULT;
274
  else
275
    return match;
276
}
277
 
278
 
279
/* Return non-zero if architecture A can run code written for
280
   architecture B.  */
281
static int
282
can_run_code_for (const struct bfd_arch_info *a, const struct bfd_arch_info *b)
283
{
284
  /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
285
     incompatible.  But if they are compatible, it returns the 'more
286
     featureful' of the two arches.  That is, if A can run code
287
     written for B, but B can't run code written for A, then it'll
288
     return A.
289
 
290
     struct bfd_arch_info objects are singletons: that is, there's
291
     supposed to be exactly one instance for a given machine.  So you
292
     can tell whether two are equivalent by comparing pointers.  */
293
  return (a == b || a->compatible (a, b) == a);
294
}
295
 
296
 
297
void
298
gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
299
{
300
  struct gdb_osabi_handler *handler;
301
 
302
  if (info.osabi == GDB_OSABI_UNKNOWN)
303
    {
304
      /* Don't complain about an unknown OSABI.  Assume the user knows
305
         what they are doing.  */
306
      return;
307
    }
308
 
309
  for (handler = gdb_osabi_handler_list; handler != NULL;
310
       handler = handler->next)
311
    {
312
      if (handler->osabi != info.osabi)
313
        continue;
314
 
315
      /* If the architecture described by ARCH_INFO can run code for
316
         the architcture we registered the handler for, then the
317
         handler is applicable.  Note, though, that if the handler is
318
         for an architecture that is a superset of ARCH_INFO, we can't
319
         use that --- it would be perfectly correct for it to install
320
         gdbarch methods that refer to registers / instructions /
321
         other facilities ARCH_INFO doesn't have.
322
 
323
         NOTE: kettenis/20021027: There may be more than one machine
324
         type that is compatible with the desired machine type.  Right
325
         now we simply return the first match, which is fine for now.
326
         However, we might want to do something smarter in the future.  */
327
      /* NOTE: cagney/2003-10-23: The code for "a can_run_code_for b"
328
         is implemented using BFD's compatible method (a->compatible
329
         (b) == a -- the lowest common denominator between a and b is
330
         a).  That method's definition of compatible may not be as you
331
         expect.  For instance the test "amd64 can run code for i386"
332
         (or more generally "64-bit ISA can run code for the 32-bit
333
         ISA").  BFD doesn't normally consider 32-bit and 64-bit
334
         "compatible" so it doesn't succeed.  */
335
      if (can_run_code_for (info.bfd_arch_info, handler->arch_info))
336
        {
337
          (*handler->init_osabi) (info, gdbarch);
338
          return;
339
        }
340
    }
341
 
342
  warning
343
    ("A handler for the OS ABI \"%s\" is not built into this configuration\n"
344
     "of GDB.  Attempting to continue with the default %s settings.\n",
345
     gdbarch_osabi_name (info.osabi),
346
     info.bfd_arch_info->printable_name);
347
}
348
 
349
/* Limit on the amount of data to be read.  */
350
#define MAX_NOTESZ      128
351
 
352
/* Return non-zero if NOTE matches NAME, DESCSZ and TYPE.  */
353
 
354
static int
355
check_note (bfd *abfd, asection *sect, const char *note,
356
            const char *name, unsigned long descsz, unsigned long type)
357
{
358
  unsigned long notesz;
359
 
360
  /* Calculate the size of this note.  */
361
  notesz = strlen (name) + 1;
362
  notesz = ((notesz + 3) & ~3);
363
  notesz += descsz;
364
  notesz = ((notesz + 3) & ~3);
365
 
366
  /* If this assertion triggers, increase MAX_NOTESZ.  */
367
  gdb_assert (notesz <= MAX_NOTESZ);
368
 
369
  /* Check whether SECT is big enough to comtain the complete note.  */
370
  if (notesz > bfd_section_size (abfd, sect))
371
    return 0;
372
 
373
  /* Check the note name.  */
374
  if (bfd_h_get_32 (abfd, note) != (strlen (name) + 1)
375
      || strcmp (note + 12, name) != 0)
376
    return 0;
377
 
378
  /* Check the descriptor size.  */
379
  if (bfd_h_get_32 (abfd, note + 4) != descsz)
380
    return 0;
381
 
382
  /* Check the note type.  */
383
  if (bfd_h_get_32 (abfd, note + 8) != type)
384
    return 0;
385
 
386
  return 1;
387
}
388
 
389
/* Generic sniffer for ELF flavoured files.  */
390
 
391
void
392
generic_elf_osabi_sniff_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
393
{
394
  enum gdb_osabi *osabi = obj;
395
  const char *name;
396
  unsigned int sectsize;
397
  char *note;
398
 
399
  name = bfd_get_section_name (abfd, sect);
400
  sectsize = bfd_section_size (abfd, sect);
401
 
402
  /* Limit the amount of data to read.  */
403
  if (sectsize > MAX_NOTESZ)
404
    sectsize = MAX_NOTESZ;
405
 
406
  note = alloca (sectsize);
407
  bfd_get_section_contents (abfd, sect, note, 0, sectsize);
408
 
409
  /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD.  */
410
  if (strcmp (name, ".note.ABI-tag") == 0)
411
    {
412
      /* GNU.  */
413
      if (check_note (abfd, sect, note, "GNU", 16, NT_GNU_ABI_TAG))
414
        {
415
          unsigned int abi_tag = bfd_h_get_32 (abfd, note + 16);
416
 
417
          switch (abi_tag)
418
            {
419
            case GNU_ABI_TAG_LINUX:
420
              *osabi = GDB_OSABI_LINUX;
421
              break;
422
 
423
            case GNU_ABI_TAG_HURD:
424
              *osabi = GDB_OSABI_HURD;
425
              break;
426
 
427
            case GNU_ABI_TAG_SOLARIS:
428
              *osabi = GDB_OSABI_SOLARIS;
429
              break;
430
 
431
            case GNU_ABI_TAG_FREEBSD:
432
              *osabi = GDB_OSABI_FREEBSD_ELF;
433
              break;
434
 
435
            case GNU_ABI_TAG_NETBSD:
436
              *osabi = GDB_OSABI_NETBSD_ELF;
437
              break;
438
 
439
            default:
440
              internal_error (__FILE__, __LINE__, _("\
441
generic_elf_osabi_sniff_abi_tag_sections: unknown OS number %d"),
442
                              abi_tag);
443
            }
444
          return;
445
        }
446
 
447
      /* FreeBSD.  */
448
      if (check_note (abfd, sect, note, "FreeBSD", 4, NT_FREEBSD_ABI_TAG))
449
        {
450
          /* There is no need to check the version yet.  */
451
          *osabi = GDB_OSABI_FREEBSD_ELF;
452
          return;
453
        }
454
 
455
      return;
456
    }
457
 
458
  /* .note.netbsd.ident notes, used by NetBSD.  */
459
  if (strcmp (name, ".note.netbsd.ident") == 0
460
      && check_note (abfd, sect, note, "NetBSD", 4, NT_NETBSD_IDENT))
461
    {
462
      /* There is no need to check the version yet.  */
463
      *osabi = GDB_OSABI_NETBSD_ELF;
464
      return;
465
    }
466
 
467
  /* .note.openbsd.ident notes, used by OpenBSD.  */
468
  if (strcmp (name, ".note.openbsd.ident") == 0
469
      && check_note (abfd, sect, note, "OpenBSD", 4, NT_OPENBSD_IDENT))
470
    {
471
      /* There is no need to check the version yet.  */
472
      *osabi = GDB_OSABI_OPENBSD_ELF;
473
      return;
474
    }
475
 
476
  /* .note.netbsdcore.procinfo notes, used by NetBSD.  */
477
  if (strcmp (name, ".note.netbsdcore.procinfo") == 0)
478
    {
479
      *osabi = GDB_OSABI_NETBSD_ELF;
480
      return;
481
    }
482
}
483
 
484
static enum gdb_osabi
485
generic_elf_osabi_sniffer (bfd *abfd)
486
{
487
  unsigned int elfosabi;
488
  enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
489
 
490
  elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
491
 
492
  switch (elfosabi)
493
    {
494
    case ELFOSABI_NONE:
495
      /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE
496
         (0), then the ELF structures in the file are conforming to
497
         the base specification for that machine (there are no
498
         OS-specific extensions).  In order to determine the real OS
499
         in use we must look for OS-specific notes.  */
500
      bfd_map_over_sections (abfd,
501
                             generic_elf_osabi_sniff_abi_tag_sections,
502
                             &osabi);
503
      break;
504
 
505
    case ELFOSABI_FREEBSD:
506
      osabi = GDB_OSABI_FREEBSD_ELF;
507
      break;
508
 
509
    case ELFOSABI_NETBSD:
510
      osabi = GDB_OSABI_NETBSD_ELF;
511
      break;
512
 
513
    case ELFOSABI_LINUX:
514
      osabi = GDB_OSABI_LINUX;
515
      break;
516
 
517
    case ELFOSABI_HURD:
518
      osabi = GDB_OSABI_HURD;
519
      break;
520
 
521
    case ELFOSABI_SOLARIS:
522
      osabi = GDB_OSABI_SOLARIS;
523
      break;
524
 
525
    case ELFOSABI_HPUX:
526
      /* For some reason the default value for the EI_OSABI field is
527
         ELFOSABI_HPUX for all PA-RISC targets (with the exception of
528
         GNU/Linux).  We use HP-UX ELF as the default, but let any
529
         OS-specific notes override this.  */
530
      osabi = GDB_OSABI_HPUX_ELF;
531
      bfd_map_over_sections (abfd,
532
                             generic_elf_osabi_sniff_abi_tag_sections,
533
                             &osabi);
534
      break;
535
    }
536
 
537
  if (osabi == GDB_OSABI_UNKNOWN)
538
    {
539
      /* The FreeBSD folks have been naughty; they stored the string
540
         "FreeBSD" in the padding of the e_ident field of the ELF
541
         header to "brand" their ELF binaries in FreeBSD 3.x.  */
542
      if (memcmp (&elf_elfheader (abfd)->e_ident[8],
543
                  "FreeBSD", sizeof ("FreeBSD")) == 0)
544
        osabi = GDB_OSABI_FREEBSD_ELF;
545
    }
546
 
547
  return osabi;
548
}
549
 
550
static void
551
set_osabi (char *args, int from_tty, struct cmd_list_element *c)
552
{
553
  struct gdbarch_info info;
554
 
555
  if (strcmp (set_osabi_string, "auto") == 0)
556
    user_osabi_state = osabi_auto;
557
  else if (strcmp (set_osabi_string, "default") == 0)
558
    {
559
      user_selected_osabi = GDB_OSABI_DEFAULT;
560
      user_osabi_state = osabi_user;
561
    }
562
  else if (strcmp (set_osabi_string, "none") == 0)
563
    {
564
      user_selected_osabi = GDB_OSABI_UNKNOWN;
565
      user_osabi_state = osabi_user;
566
    }
567
  else
568
    {
569
      int i;
570
      for (i = 1; i < GDB_OSABI_INVALID; i++)
571
        if (strcmp (set_osabi_string, gdbarch_osabi_name (i)) == 0)
572
          {
573
            user_selected_osabi = i;
574
            user_osabi_state = osabi_user;
575
            break;
576
          }
577
      if (i == GDB_OSABI_INVALID)
578
        internal_error (__FILE__, __LINE__,
579
                        _("Invalid OS ABI \"%s\" passed to command handler."),
580
                        set_osabi_string);
581
    }
582
 
583
  /* NOTE: At some point (true multiple architectures) we'll need to be more
584
     graceful here.  */
585
  gdbarch_info_init (&info);
586
  if (! gdbarch_update_p (info))
587
    internal_error (__FILE__, __LINE__, _("Updating OS ABI failed."));
588
}
589
 
590
static void
591
show_osabi (struct ui_file *file, int from_tty, struct cmd_list_element *c,
592
            const char *value)
593
{
594
  if (user_osabi_state == osabi_auto)
595
    fprintf_filtered (file,
596
                      _("The current OS ABI is \"auto\" (currently \"%s\").\n"),
597
                      gdbarch_osabi_name (gdbarch_osabi (current_gdbarch)));
598
  else
599
    fprintf_filtered (file, _("The current OS ABI is \"%s\".\n"),
600
                      gdbarch_osabi_name (user_selected_osabi));
601
 
602
  if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN)
603
    fprintf_filtered (file, _("The default OS ABI is \"%s\".\n"),
604
                      gdbarch_osabi_name (GDB_OSABI_DEFAULT));
605
}
606
 
607
extern initialize_file_ftype _initialize_gdb_osabi; /* -Wmissing-prototype */
608
 
609
void
610
_initialize_gdb_osabi (void)
611
{
612
  struct cmd_list_element *c;
613
 
614
  if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID], "<invalid>") != 0)
615
    internal_error
616
      (__FILE__, __LINE__,
617
       _("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent"));
618
 
619
  /* Register a generic sniffer for ELF flavoured files.  */
620
  gdbarch_register_osabi_sniffer (bfd_arch_unknown,
621
                                  bfd_target_elf_flavour,
622
                                  generic_elf_osabi_sniffer);
623
 
624
  /* Register the "set osabi" command.  */
625
  add_setshow_enum_cmd ("osabi", class_support, gdb_osabi_available_names,
626
                        &set_osabi_string, _("\
627
Set OS ABI of target."), _("\
628
Show OS ABI of target."), NULL,
629
                        set_osabi,
630
                        show_osabi,
631
                        &setlist, &showlist);
632
  user_osabi_state = osabi_auto;
633
}

powered by: WebSVN 2.1.0

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