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