OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [osabi.c] - Blame information for rev 227

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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