daily update
[binutils.git] / bfd / rs6000-core.c
bloba848d08dc361f11f47e70c81a2f6b9978b273eff
1 /* IBM RS/6000 "XCOFF" back-end for BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
3 2001, 2002, 2004, 2006
4 Free Software Foundation, Inc.
5 FIXME: Can someone provide a transliteration of this name into ASCII?
6 Using the following chars caused a compiler warning on HIUX (so I replaced
7 them with octal escapes), and isn't useful without an understanding of what
8 character set it is.
9 Written by Metin G. Ozisik, Mimi Ph\373\364ng-Th\345o V\365,
10 and John Gilmore.
11 Archive support from Damon A. Permezel.
12 Contributed by IBM Corporation and Cygnus Support.
14 This file is part of BFD, the Binary File Descriptor library.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 2 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
30 /* This port currently only handles reading object files, except when
31 compiled on an RS/6000 host. -- no archive support, no core files.
32 In all cases, it does not support writing.
34 This is in a separate file from coff-rs6000.c, because it includes
35 system include files that conflict with coff/rs6000.h. */
37 /* Internalcoff.h and coffcode.h modify themselves based on this flag. */
38 #define RS6000COFF_C 1
40 /* The AIX 4.1 kernel is obviously compiled with -D_LONG_LONG, so
41 we have to define _LONG_LONG for older versions of gcc to get the
42 proper alignments in the user structure. */
43 #if defined(_AIX41) && !defined(_LONG_LONG)
44 #define _LONG_LONG
45 #endif
47 #include "bfd.h"
48 #include "sysdep.h"
49 #include "libbfd.h"
51 #ifdef AIX_CORE
53 /* AOUTHDR is defined by the above. We need another defn of it, from the
54 system include files. Punt the old one and get us a new name for the
55 typedef in the system include files. */
56 #ifdef AOUTHDR
57 #undef AOUTHDR
58 #endif
59 #define AOUTHDR second_AOUTHDR
61 #undef SCNHDR
63 /* ------------------------------------------------------------------------ */
64 /* Support for core file stuff.. */
65 /* ------------------------------------------------------------------------ */
67 #include <sys/user.h>
68 #define __LDINFO_PTRACE32__ /* for __ld_info32 */
69 #define __LDINFO_PTRACE64__ /* for __ld_info64 */
70 #include <sys/ldr.h>
71 #include <sys/core.h>
72 #include <sys/systemcfg.h>
74 /* Borrowed from <sys/inttypes.h> on recent AIX versions. */
75 typedef unsigned long ptr_to_uint;
77 #define core_hdr(bfd) ((CoreHdr *) bfd->tdata.any)
79 /* AIX 4.1 changed the names and locations of a few items in the core file.
80 AIX 4.3 defined an entirely new structure, core_dumpx, but kept support for
81 the previous 4.1 structure, core_dump.
83 AIX_CORE_DUMPX_CORE is defined (by configure) on AIX 4.3+, and
84 CORE_VERSION_1 is defined (by AIX core.h) as 2 on AIX 4.3+ and as 1 on AIX
85 4.1 and 4.2. AIX pre-4.1 (aka 3.x) either doesn't define CORE_VERSION_1
86 or else defines it as 0. */
88 #if defined(CORE_VERSION_1) && !CORE_VERSION_1
89 # undef CORE_VERSION_1
90 #endif
92 /* The following union and macros allow this module to compile on all AIX
93 versions and to handle both core_dumpx and core_dump on 4.3+. CNEW_*()
94 and COLD_*() macros respectively retrieve core_dumpx and core_dump
95 values. */
97 /* Union of 32-bit and 64-bit versions of ld_info. */
99 typedef union {
100 #ifdef __ld_info32
101 struct __ld_info32 l32;
102 struct __ld_info64 l64;
103 #else
104 struct ld_info l32;
105 struct ld_info l64;
106 #endif
107 } LdInfo;
109 /* Union of old and new core dump structures. */
111 typedef union {
112 #ifdef AIX_CORE_DUMPX_CORE
113 struct core_dumpx new; /* new AIX 4.3+ core dump */
114 #else
115 struct core_dump new; /* for simpler coding */
116 #endif
117 struct core_dump old; /* old AIX 4.2- core dump, still used on
118 4.3+ with appropriate SMIT config */
119 } CoreHdr;
121 /* Union of old and new vm_info structures. */
123 #ifdef CORE_VERSION_1
124 typedef union {
125 #ifdef AIX_CORE_DUMPX_CORE
126 struct vm_infox new;
127 #else
128 struct vm_info new;
129 #endif
130 struct vm_info old;
131 } VmInfo;
132 #endif
134 /* Return whether CoreHdr C is in new or old format. */
136 #ifdef AIX_CORE_DUMPX_CORE
137 # define CORE_NEW(c) (!(c).old.c_entries)
138 #else
139 # define CORE_NEW(c) 0
140 #endif
142 /* Return the c_stackorg field from struct core_dumpx C. */
144 #ifdef AIX_CORE_DUMPX_CORE
145 # define CNEW_STACKORG(c) (c).c_stackorg
146 #else
147 # define CNEW_STACKORG(c) 0
148 #endif
150 /* Return the offset to the loader region from struct core_dump C. */
152 #ifdef AIX_CORE_DUMPX_CORE
153 # define CNEW_LOADER(c) (c).c_loader
154 #else
155 # define CNEW_LOADER(c) 0
156 #endif
158 /* Return the offset to the loader region from struct core_dump C. */
160 #define COLD_LOADER(c) (c).c_tab
162 /* Return the c_lsize field from struct core_dumpx C. */
164 #ifdef AIX_CORE_DUMPX_CORE
165 # define CNEW_LSIZE(c) (c).c_lsize
166 #else
167 # define CNEW_LSIZE(c) 0
168 #endif
170 /* Return the c_dataorg field from struct core_dumpx C. */
172 #ifdef AIX_CORE_DUMPX_CORE
173 # define CNEW_DATAORG(c) (c).c_dataorg
174 #else
175 # define CNEW_DATAORG(c) 0
176 #endif
178 /* Return the c_datasize field from struct core_dumpx C. */
180 #ifdef AIX_CORE_DUMPX_CORE
181 # define CNEW_DATASIZE(c) (c).c_datasize
182 #else
183 # define CNEW_DATASIZE(c) 0
184 #endif
186 /* Return the c_impl field from struct core_dumpx C. */
188 #if defined (HAVE_ST_C_IMPL) || defined (AIX_5_CORE)
189 # define CNEW_IMPL(c) (c).c_impl
190 #else
191 # define CNEW_IMPL(c) 0
192 #endif
194 /* Return the command string from struct core_dumpx C. */
196 #ifdef AIX_CORE_DUMPX_CORE
197 # define CNEW_COMM(c) (c).c_u.U_proc.pi_comm
198 #else
199 # define CNEW_COMM(c) 0
200 #endif
202 /* Return the command string from struct core_dump C. */
204 #ifdef CORE_VERSION_1
205 # define COLD_COMM(c) (c).c_u.U_comm
206 #else
207 # define COLD_COMM(c) (c).c_u.u_comm
208 #endif
210 /* Return the struct __context64 pointer from struct core_dumpx C. */
212 #ifdef AIX_CORE_DUMPX_CORE
213 # define CNEW_CONTEXT64(c) (c).c_flt.hctx.r64
214 #else
215 # define CNEW_CONTEXT64(c) c
216 #endif
218 /* Return the struct mstsave pointer from struct core_dumpx C. */
220 #ifdef AIX_CORE_DUMPX_CORE
221 # define CNEW_MSTSAVE(c) (c).c_flt.hctx.r32
222 #else
223 # define CNEW_MSTSAVE(c) c
224 #endif
226 /* Return the struct mstsave pointer from struct core_dump C. */
228 #ifdef CORE_VERSION_1
229 # define COLD_MSTSAVE(c) (c).c_mst
230 #else
231 # define COLD_MSTSAVE(c) (c).c_u.u_save
232 #endif
234 /* Return whether struct core_dumpx is from a 64-bit process. */
236 #ifdef AIX_CORE_DUMPX_CORE
237 # define CNEW_PROC64(c) IS_PROC64(&(c).c_u.U_proc)
238 #else
239 # define CNEW_PROC64(c) 0
240 #endif
242 /* Magic end-of-stack addresses for old core dumps. This is _very_ fragile,
243 but I don't see any easy way to get that info right now. */
245 #ifdef CORE_VERSION_1
246 # define COLD_STACKEND 0x2ff23000
247 #else
248 # define COLD_STACKEND 0x2ff80000
249 #endif
251 /* Size of the leading portion that old and new core dump structures have in
252 common. */
253 #define CORE_COMMONSZ ((int) &((struct core_dump *) 0)->c_entries \
254 + sizeof (((struct core_dump *) 0)->c_entries))
256 /* Define prototypes for certain functions, to avoid a compiler warning
257 saying that they are missing. */
259 const bfd_target * rs6000coff_core_p (bfd *abfd);
260 bfd_boolean rs6000coff_core_file_matches_executable_p (bfd *core_bfd,
261 bfd *exec_bfd);
262 char * rs6000coff_core_file_failing_command (bfd *abfd);
263 int rs6000coff_core_file_failing_signal (bfd *abfd);
265 /* Try to read into CORE the header from the core file associated with ABFD.
266 Return success. */
268 static bfd_boolean
269 read_hdr (bfd *abfd, CoreHdr *core)
271 bfd_size_type size;
273 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
274 return FALSE;
276 /* Read the leading portion that old and new core dump structures have in
277 common. */
278 size = CORE_COMMONSZ;
279 if (bfd_bread (core, size, abfd) != size)
280 return FALSE;
282 /* Read the trailing portion of the structure. */
283 if (CORE_NEW (*core))
284 size = sizeof (core->new);
285 else
286 size = sizeof (core->old);
287 size -= CORE_COMMONSZ;
288 return bfd_bread ((char *) core + CORE_COMMONSZ, size, abfd) == size;
291 static asection *
292 make_bfd_asection (bfd *abfd, const char *name, flagword flags,
293 bfd_size_type size, bfd_vma vma, file_ptr filepos)
295 asection *asect;
297 asect = bfd_make_section_anyway_with_flags (abfd, name, flags);
298 if (!asect)
299 return NULL;
301 asect->size = size;
302 asect->vma = vma;
303 asect->filepos = filepos;
304 asect->alignment_power = 8;
306 return asect;
309 /* Decide if a given bfd represents a `core' file or not. There really is no
310 magic number or anything like, in rs6000coff. */
312 const bfd_target *
313 rs6000coff_core_p (bfd *abfd)
315 CoreHdr core;
316 struct stat statbuf;
317 bfd_size_type size;
318 char *tmpptr;
320 /* Values from new and old core structures. */
321 int c_flag;
322 file_ptr c_stack, c_regoff, c_loader;
323 bfd_size_type c_size, c_regsize, c_lsize;
324 bfd_vma c_stackend;
325 void *c_regptr;
326 int proc64;
328 if (!read_hdr (abfd, &core))
330 if (bfd_get_error () != bfd_error_system_call)
331 bfd_set_error (bfd_error_wrong_format);
332 return NULL;
335 /* Copy fields from new or old core structure. */
336 if (CORE_NEW (core))
338 c_flag = core.new.c_flag;
339 c_stack = (file_ptr) core.new.c_stack;
340 c_size = core.new.c_size;
341 c_stackend = CNEW_STACKORG (core.new) + c_size;
342 c_lsize = CNEW_LSIZE (core.new);
343 c_loader = CNEW_LOADER (core.new);
344 proc64 = CNEW_PROC64 (core.new);
346 else
348 c_flag = core.old.c_flag;
349 c_stack = (file_ptr) (ptr_to_uint) core.old.c_stack;
350 c_size = core.old.c_size;
351 c_stackend = COLD_STACKEND;
352 c_lsize = 0x7ffffff;
353 c_loader = (file_ptr) (ptr_to_uint) COLD_LOADER (core.old);
354 proc64 = 0;
357 if (proc64)
359 c_regsize = sizeof (CNEW_CONTEXT64 (core.new));
360 c_regptr = &CNEW_CONTEXT64 (core.new);
362 else if (CORE_NEW (core))
364 c_regsize = sizeof (CNEW_MSTSAVE (core.new));
365 c_regptr = &CNEW_MSTSAVE (core.new);
367 else
369 c_regsize = sizeof (COLD_MSTSAVE (core.old));
370 c_regptr = &COLD_MSTSAVE (core.old);
372 c_regoff = (char *) c_regptr - (char *) &core;
374 if (bfd_stat (abfd, &statbuf) < 0)
376 bfd_set_error (bfd_error_system_call);
377 return NULL;
380 /* If the core file ulimit is too small, the system will first
381 omit the data segment, then omit the stack, then decline to
382 dump core altogether (as far as I know UBLOCK_VALID and LE_VALID
383 are always set) (this is based on experimentation on AIX 3.2).
384 Now, the thing is that GDB users will be surprised
385 if segments just silently don't appear (well, maybe they would
386 think to check "info files", I don't know).
388 For the data segment, we have no choice but to keep going if it's
389 not there, since the default behavior is not to dump it (regardless
390 of the ulimit, it's based on SA_FULLDUMP). But for the stack segment,
391 if it's not there, we refuse to have anything to do with this core
392 file. The usefulness of a core dump without a stack segment is pretty
393 limited anyway. */
395 if (!(c_flag & UBLOCK_VALID)
396 || !(c_flag & LE_VALID))
398 bfd_set_error (bfd_error_wrong_format);
399 return NULL;
402 if (!(c_flag & USTACK_VALID))
404 bfd_set_error (bfd_error_file_truncated);
405 return NULL;
408 /* Don't check the core file size for a full core, AIX 4.1 includes
409 additional shared library sections in a full core. */
410 if (!(c_flag & (FULL_CORE | CORE_TRUNC)))
412 /* If the size is wrong, it means we're misinterpreting something. */
413 if (c_stack + (file_ptr) c_size != statbuf.st_size)
415 bfd_set_error (bfd_error_wrong_format);
416 return NULL;
420 /* Sanity check on the c_tab field. */
421 if (!CORE_NEW (core) && (c_loader < (file_ptr) sizeof core.old ||
422 c_loader >= statbuf.st_size ||
423 c_loader >= c_stack))
425 bfd_set_error (bfd_error_wrong_format);
426 return NULL;
429 /* Issue warning if the core file was truncated during writing. */
430 if (c_flag & CORE_TRUNC)
431 (*_bfd_error_handler) (_("%s: warning core file truncated"),
432 bfd_get_filename (abfd));
434 /* Allocate core file header. */
435 size = CORE_NEW (core) ? sizeof (core.new) : sizeof (core.old);
436 tmpptr = (char *) bfd_zalloc (abfd, (bfd_size_type) size);
437 if (!tmpptr)
438 return NULL;
440 /* Copy core file header. */
441 memcpy (tmpptr, &core, size);
442 set_tdata (abfd, tmpptr);
444 /* Set architecture. */
445 if (CORE_NEW (core))
447 enum bfd_architecture arch;
448 unsigned long mach;
450 switch (CNEW_IMPL (core.new))
452 case POWER_RS1:
453 case POWER_RSC:
454 case POWER_RS2:
455 arch = bfd_arch_rs6000;
456 mach = bfd_mach_rs6k;
457 break;
458 default:
459 arch = bfd_arch_powerpc;
460 mach = bfd_mach_ppc;
461 break;
463 bfd_default_set_arch_mach (abfd, arch, mach);
466 /* .stack section. */
467 if (!make_bfd_asection (abfd, ".stack",
468 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
469 c_size, c_stackend - c_size, c_stack))
470 goto fail;
472 /* .reg section for all registers. */
473 if (!make_bfd_asection (abfd, ".reg",
474 SEC_HAS_CONTENTS,
475 c_regsize, (bfd_vma) 0, c_regoff))
476 goto fail;
478 /* .ldinfo section.
479 To actually find out how long this section is in this particular
480 core dump would require going down the whole list of struct ld_info's.
481 See if we can just fake it. */
482 if (!make_bfd_asection (abfd, ".ldinfo",
483 SEC_HAS_CONTENTS,
484 c_lsize, (bfd_vma) 0, c_loader))
485 goto fail;
487 #ifndef CORE_VERSION_1
488 /* .data section if present.
489 AIX 3 dumps the complete data section and sets FULL_CORE if the
490 ulimit is large enough, otherwise the data section is omitted.
491 AIX 4 sets FULL_CORE even if the core file is truncated, we have
492 to examine core.c_datasize below to find out the actual size of
493 the .data section. */
494 if (c_flag & FULL_CORE)
496 if (!make_bfd_asection (abfd, ".data",
497 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
498 (bfd_size_type) core.old.c_u.u_dsize,
499 (bfd_vma)
500 CDATA_ADDR (core.old.c_u.u_dsize),
501 c_stack + c_size))
502 goto fail;
504 #endif
506 #ifdef CORE_VERSION_1
507 /* AIX 4 adds data sections from loaded objects to the core file,
508 which can be found by examining ldinfo, and anonymously mmapped
509 regions. */
511 LdInfo ldinfo;
512 bfd_size_type ldi_datasize;
513 file_ptr ldi_core;
514 uint ldi_next;
515 bfd_vma ldi_dataorg;
517 /* Fields from new and old core structures. */
518 bfd_size_type c_datasize, c_vmregions;
519 file_ptr c_data, c_vmm;
521 if (CORE_NEW (core))
523 c_datasize = CNEW_DATASIZE (core.new);
524 c_data = (file_ptr) core.new.c_data;
525 c_vmregions = core.new.c_vmregions;
526 c_vmm = (file_ptr) core.new.c_vmm;
528 else
530 c_datasize = core.old.c_datasize;
531 c_data = (file_ptr) (ptr_to_uint) core.old.c_data;
532 c_vmregions = core.old.c_vmregions;
533 c_vmm = (file_ptr) (ptr_to_uint) core.old.c_vmm;
536 /* .data section from executable. */
537 if (c_datasize)
539 if (!make_bfd_asection (abfd, ".data",
540 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
541 c_datasize,
542 (bfd_vma) CDATA_ADDR (c_datasize),
543 c_data))
544 goto fail;
547 /* .data sections from loaded objects. */
548 if (proc64)
549 size = (int) ((LdInfo *) 0)->l64.ldinfo_filename;
550 else
551 size = (int) ((LdInfo *) 0)->l32.ldinfo_filename;
553 while (1)
555 if (bfd_seek (abfd, c_loader, SEEK_SET) != 0)
556 goto fail;
557 if (bfd_bread (&ldinfo, size, abfd) != size)
558 goto fail;
560 if (proc64)
562 ldi_core = ldinfo.l64.ldinfo_core;
563 ldi_datasize = ldinfo.l64.ldinfo_datasize;
564 ldi_dataorg = (bfd_vma) ldinfo.l64.ldinfo_dataorg;
565 ldi_next = ldinfo.l64.ldinfo_next;
567 else
569 ldi_core = ldinfo.l32.ldinfo_core;
570 ldi_datasize = ldinfo.l32.ldinfo_datasize;
571 ldi_dataorg = (bfd_vma) (long) ldinfo.l32.ldinfo_dataorg;
572 ldi_next = ldinfo.l32.ldinfo_next;
575 if (ldi_core)
576 if (!make_bfd_asection (abfd, ".data",
577 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
578 ldi_datasize, ldi_dataorg, ldi_core))
579 goto fail;
581 if (ldi_next == 0)
582 break;
583 c_loader += ldi_next;
586 /* .vmdata sections from anonymously mmapped regions. */
587 if (c_vmregions)
589 bfd_size_type i;
591 if (bfd_seek (abfd, c_vmm, SEEK_SET) != 0)
592 goto fail;
594 for (i = 0; i < c_vmregions; i++)
596 VmInfo vminfo;
597 bfd_size_type vminfo_size;
598 file_ptr vminfo_offset;
599 bfd_vma vminfo_addr;
601 size = CORE_NEW (core) ? sizeof (vminfo.new) : sizeof (vminfo.old);
602 if (bfd_bread (&vminfo, size, abfd) != size)
603 goto fail;
605 if (CORE_NEW (core))
607 vminfo_addr = (bfd_vma) vminfo.new.vminfo_addr;
608 vminfo_size = vminfo.new.vminfo_size;
609 vminfo_offset = vminfo.new.vminfo_offset;
611 else
613 vminfo_addr = (bfd_vma) (long) vminfo.old.vminfo_addr;
614 vminfo_size = vminfo.old.vminfo_size;
615 vminfo_offset = vminfo.old.vminfo_offset;
618 if (vminfo_offset)
619 if (!make_bfd_asection (abfd, ".vmdata",
620 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
621 vminfo_size, vminfo_addr,
622 vminfo_offset))
623 goto fail;
627 #endif
629 return abfd->xvec; /* This is garbage for now. */
631 fail:
632 bfd_release (abfd, abfd->tdata.any);
633 abfd->tdata.any = NULL;
634 bfd_section_list_clear (abfd);
635 return NULL;
638 /* Return `TRUE' if given core is from the given executable. */
640 bfd_boolean
641 rs6000coff_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd)
643 CoreHdr core;
644 bfd_size_type size;
645 char *path, *s;
646 size_t alloc;
647 const char *str1, *str2;
648 bfd_boolean ret;
649 file_ptr c_loader;
651 if (!read_hdr (core_bfd, &core))
652 return FALSE;
654 if (CORE_NEW (core))
655 c_loader = CNEW_LOADER (core.new);
656 else
657 c_loader = (file_ptr) (ptr_to_uint) COLD_LOADER (core.old);
659 if (CORE_NEW (core) && CNEW_PROC64 (core.new))
660 size = (int) ((LdInfo *) 0)->l64.ldinfo_filename;
661 else
662 size = (int) ((LdInfo *) 0)->l32.ldinfo_filename;
664 if (bfd_seek (core_bfd, c_loader + size, SEEK_SET) != 0)
665 return FALSE;
667 alloc = 100;
668 path = bfd_malloc ((bfd_size_type) alloc);
669 if (path == NULL)
670 return FALSE;
671 s = path;
673 while (1)
675 if (bfd_bread (s, (bfd_size_type) 1, core_bfd) != 1)
677 free (path);
678 return FALSE;
680 if (*s == '\0')
681 break;
682 ++s;
683 if (s == path + alloc)
685 char *n;
687 alloc *= 2;
688 n = bfd_realloc (path, (bfd_size_type) alloc);
689 if (n == NULL)
691 free (path);
692 return FALSE;
694 s = n + (path - s);
695 path = n;
699 str1 = strrchr (path, '/');
700 str2 = strrchr (exec_bfd->filename, '/');
702 /* step over character '/' */
703 str1 = str1 != NULL ? str1 + 1 : path;
704 str2 = str2 != NULL ? str2 + 1 : exec_bfd->filename;
706 if (strcmp (str1, str2) == 0)
707 ret = TRUE;
708 else
709 ret = FALSE;
711 free (path);
713 return ret;
716 char *
717 rs6000coff_core_file_failing_command (bfd *abfd)
719 CoreHdr *core = core_hdr (abfd);
720 char *com = CORE_NEW (*core) ?
721 CNEW_COMM (core->new) : COLD_COMM (core->old);
723 if (*com)
724 return com;
725 else
726 return 0;
730 rs6000coff_core_file_failing_signal (bfd *abfd)
732 CoreHdr *core = core_hdr (abfd);
733 return CORE_NEW (*core) ? core->new.c_signo : core->old.c_signo;
736 #endif /* AIX_CORE */