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