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