Update
[gdb.git] / bfd / rs6000-core.c
blobeb0eb5227859510b14ee22316abece28f0dcb392
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, 2007
4 Free Software Foundation, Inc.
5 Written by Metin G. Ozisik, Mimi Phuong-Thao Vo, and John Gilmore.
6 Archive support from Damon A. Permezel.
7 Contributed by IBM Corporation and Cygnus Support.
9 This file is part of BFD, the Binary File Descriptor library.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
24 MA 02110-1301, USA. */
27 /* This port currently only handles reading object files, except when
28 compiled on an RS/6000 host. -- no archive support, no core files.
29 In all cases, it does not support writing.
31 This is in a separate file from coff-rs6000.c, because it includes
32 system include files that conflict with coff/rs6000.h. */
34 /* Internalcoff.h and coffcode.h modify themselves based on this flag. */
35 #define RS6000COFF_C 1
37 /* The AIX 4.1 kernel is obviously compiled with -D_LONG_LONG, so
38 we have to define _LONG_LONG for older versions of gcc to get the
39 proper alignments in the user structure. */
40 #if defined(_AIX41) && !defined(_LONG_LONG)
41 #define _LONG_LONG
42 #endif
44 #include "sysdep.h"
45 #include "bfd.h"
46 #include "libbfd.h"
48 #ifdef AIX_CORE
50 /* AOUTHDR is defined by the above. We need another defn of it, from the
51 system include files. Punt the old one and get us a new name for the
52 typedef in the system include files. */
53 #ifdef AOUTHDR
54 #undef AOUTHDR
55 #endif
56 #define AOUTHDR second_AOUTHDR
58 #undef SCNHDR
60 /* ------------------------------------------------------------------------ */
61 /* Support for core file stuff.. */
62 /* ------------------------------------------------------------------------ */
64 #include <sys/user.h>
65 #define __LDINFO_PTRACE32__ /* for __ld_info32 */
66 #define __LDINFO_PTRACE64__ /* for __ld_info64 */
67 #include <sys/ldr.h>
68 #include <sys/core.h>
69 #include <sys/systemcfg.h>
71 /* Borrowed from <sys/inttypes.h> on recent AIX versions. */
72 typedef unsigned long ptr_to_uint;
74 #define core_hdr(bfd) ((CoreHdr *) bfd->tdata.any)
76 /* AIX 4.1 changed the names and locations of a few items in the core file.
77 AIX 4.3 defined an entirely new structure, core_dumpx, but kept support for
78 the previous 4.1 structure, core_dump.
80 AIX_CORE_DUMPX_CORE is defined (by configure) on AIX 4.3+, and
81 CORE_VERSION_1 is defined (by AIX core.h) as 2 on AIX 4.3+ and as 1 on AIX
82 4.1 and 4.2. AIX pre-4.1 (aka 3.x) either doesn't define CORE_VERSION_1
83 or else defines it as 0. */
85 #if defined(CORE_VERSION_1) && !CORE_VERSION_1
86 # undef CORE_VERSION_1
87 #endif
89 /* The following union and macros allow this module to compile on all AIX
90 versions and to handle both core_dumpx and core_dump on 4.3+. CNEW_*()
91 and COLD_*() macros respectively retrieve core_dumpx and core_dump
92 values. */
94 /* Union of 32-bit and 64-bit versions of ld_info. */
96 typedef union {
97 #ifdef __ld_info32
98 struct __ld_info32 l32;
99 struct __ld_info64 l64;
100 #else
101 struct ld_info l32;
102 struct ld_info l64;
103 #endif
104 } LdInfo;
106 /* Union of old and new core dump structures. */
108 typedef union {
109 #ifdef AIX_CORE_DUMPX_CORE
110 struct core_dumpx new; /* new AIX 4.3+ core dump */
111 #else
112 struct core_dump new; /* for simpler coding */
113 #endif
114 struct core_dump old; /* old AIX 4.2- core dump, still used on
115 4.3+ with appropriate SMIT config */
116 } CoreHdr;
118 /* Union of old and new vm_info structures. */
120 #ifdef CORE_VERSION_1
121 typedef union {
122 #ifdef AIX_CORE_DUMPX_CORE
123 struct vm_infox new;
124 #else
125 struct vm_info new;
126 #endif
127 struct vm_info old;
128 } VmInfo;
129 #endif
131 /* Return whether CoreHdr C is in new or old format. */
133 #ifdef AIX_CORE_DUMPX_CORE
134 # define CORE_NEW(c) (!(c).old.c_entries)
135 #else
136 # define CORE_NEW(c) 0
137 #endif
139 /* Return the c_stackorg field from struct core_dumpx C. */
141 #ifdef AIX_CORE_DUMPX_CORE
142 # define CNEW_STACKORG(c) (c).c_stackorg
143 #else
144 # define CNEW_STACKORG(c) 0
145 #endif
147 /* Return the offset to the loader region from struct core_dump C. */
149 #ifdef AIX_CORE_DUMPX_CORE
150 # define CNEW_LOADER(c) (c).c_loader
151 #else
152 # define CNEW_LOADER(c) 0
153 #endif
155 /* Return the offset to the loader region from struct core_dump C. */
157 #define COLD_LOADER(c) (c).c_tab
159 /* Return the c_lsize field from struct core_dumpx C. */
161 #ifdef AIX_CORE_DUMPX_CORE
162 # define CNEW_LSIZE(c) (c).c_lsize
163 #else
164 # define CNEW_LSIZE(c) 0
165 #endif
167 /* Return the c_dataorg field from struct core_dumpx C. */
169 #ifdef AIX_CORE_DUMPX_CORE
170 # define CNEW_DATAORG(c) (c).c_dataorg
171 #else
172 # define CNEW_DATAORG(c) 0
173 #endif
175 /* Return the c_datasize field from struct core_dumpx C. */
177 #ifdef AIX_CORE_DUMPX_CORE
178 # define CNEW_DATASIZE(c) (c).c_datasize
179 #else
180 # define CNEW_DATASIZE(c) 0
181 #endif
183 /* Return the c_impl field from struct core_dumpx C. */
185 #if defined (HAVE_ST_C_IMPL) || defined (AIX_5_CORE)
186 # define CNEW_IMPL(c) (c).c_impl
187 #else
188 # define CNEW_IMPL(c) 0
189 #endif
191 /* Return the command string from struct core_dumpx C. */
193 #ifdef AIX_CORE_DUMPX_CORE
194 # define CNEW_COMM(c) (c).c_u.U_proc.pi_comm
195 #else
196 # define CNEW_COMM(c) 0
197 #endif
199 /* Return the command string from struct core_dump C. */
201 #ifdef CORE_VERSION_1
202 # define COLD_COMM(c) (c).c_u.U_comm
203 #else
204 # define COLD_COMM(c) (c).c_u.u_comm
205 #endif
207 /* Return the struct __context64 pointer from struct core_dumpx C. */
209 #ifdef AIX_CORE_DUMPX_CORE
210 # define CNEW_CONTEXT64(c) (c).c_flt.hctx.r64
211 #else
212 # define CNEW_CONTEXT64(c) c
213 #endif
215 /* Return the struct mstsave pointer from struct core_dumpx C. */
217 #ifdef AIX_CORE_DUMPX_CORE
218 # define CNEW_MSTSAVE(c) (c).c_flt.hctx.r32
219 #else
220 # define CNEW_MSTSAVE(c) c
221 #endif
223 /* Return the struct mstsave pointer from struct core_dump C. */
225 #ifdef CORE_VERSION_1
226 # define COLD_MSTSAVE(c) (c).c_mst
227 #else
228 # define COLD_MSTSAVE(c) (c).c_u.u_save
229 #endif
231 /* Return whether struct core_dumpx is from a 64-bit process. */
233 #ifdef AIX_CORE_DUMPX_CORE
234 # define CNEW_PROC64(c) IS_PROC64(&(c).c_u.U_proc)
235 #else
236 # define CNEW_PROC64(c) 0
237 #endif
239 /* Magic end-of-stack addresses for old core dumps. This is _very_ fragile,
240 but I don't see any easy way to get that info right now. */
242 #ifdef CORE_VERSION_1
243 # define COLD_STACKEND 0x2ff23000
244 #else
245 # define COLD_STACKEND 0x2ff80000
246 #endif
248 /* Size of the leading portion that old and new core dump structures have in
249 common. */
250 #define CORE_COMMONSZ ((int) &((struct core_dump *) 0)->c_entries \
251 + sizeof (((struct core_dump *) 0)->c_entries))
253 /* Define prototypes for certain functions, to avoid a compiler warning
254 saying that they are missing. */
256 const bfd_target * rs6000coff_core_p (bfd *abfd);
257 bfd_boolean rs6000coff_core_file_matches_executable_p (bfd *core_bfd,
258 bfd *exec_bfd);
259 char * rs6000coff_core_file_failing_command (bfd *abfd);
260 int rs6000coff_core_file_failing_signal (bfd *abfd);
262 /* Try to read into CORE the header from the core file associated with ABFD.
263 Return success. */
265 static bfd_boolean
266 read_hdr (bfd *abfd, CoreHdr *core)
268 bfd_size_type size;
270 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
271 return FALSE;
273 /* Read the leading portion that old and new core dump structures have in
274 common. */
275 size = CORE_COMMONSZ;
276 if (bfd_bread (core, size, abfd) != size)
277 return FALSE;
279 /* Read the trailing portion of the structure. */
280 if (CORE_NEW (*core))
281 size = sizeof (core->new);
282 else
283 size = sizeof (core->old);
284 size -= CORE_COMMONSZ;
285 return bfd_bread ((char *) core + CORE_COMMONSZ, size, abfd) == size;
288 static asection *
289 make_bfd_asection (bfd *abfd, const char *name, flagword flags,
290 bfd_size_type size, bfd_vma vma, file_ptr filepos)
292 asection *asect;
294 asect = bfd_make_section_anyway_with_flags (abfd, name, flags);
295 if (!asect)
296 return NULL;
298 asect->size = size;
299 asect->vma = vma;
300 asect->filepos = filepos;
301 asect->alignment_power = 8;
303 return asect;
306 /* Decide if a given bfd represents a `core' file or not. There really is no
307 magic number or anything like, in rs6000coff. */
309 const bfd_target *
310 rs6000coff_core_p (bfd *abfd)
312 CoreHdr core;
313 struct stat statbuf;
314 bfd_size_type size;
315 char *tmpptr;
317 /* Values from new and old core structures. */
318 int c_flag;
319 file_ptr c_stack, c_regoff, c_loader;
320 bfd_size_type c_size, c_regsize, c_lsize;
321 bfd_vma c_stackend;
322 void *c_regptr;
323 int proc64;
325 if (!read_hdr (abfd, &core))
327 if (bfd_get_error () != bfd_error_system_call)
328 bfd_set_error (bfd_error_wrong_format);
329 return NULL;
332 /* Copy fields from new or old core structure. */
333 if (CORE_NEW (core))
335 c_flag = core.new.c_flag;
336 c_stack = (file_ptr) core.new.c_stack;
337 c_size = core.new.c_size;
338 c_stackend = CNEW_STACKORG (core.new) + c_size;
339 c_lsize = CNEW_LSIZE (core.new);
340 c_loader = CNEW_LOADER (core.new);
341 proc64 = CNEW_PROC64 (core.new);
343 else
345 c_flag = core.old.c_flag;
346 c_stack = (file_ptr) (ptr_to_uint) core.old.c_stack;
347 c_size = core.old.c_size;
348 c_stackend = COLD_STACKEND;
349 c_lsize = 0x7ffffff;
350 c_loader = (file_ptr) (ptr_to_uint) COLD_LOADER (core.old);
351 proc64 = 0;
354 if (proc64)
356 c_regsize = sizeof (CNEW_CONTEXT64 (core.new));
357 c_regptr = &CNEW_CONTEXT64 (core.new);
359 else if (CORE_NEW (core))
361 c_regsize = sizeof (CNEW_MSTSAVE (core.new));
362 c_regptr = &CNEW_MSTSAVE (core.new);
364 else
366 c_regsize = sizeof (COLD_MSTSAVE (core.old));
367 c_regptr = &COLD_MSTSAVE (core.old);
369 c_regoff = (char *) c_regptr - (char *) &core;
371 if (bfd_stat (abfd, &statbuf) < 0)
373 bfd_set_error (bfd_error_system_call);
374 return NULL;
377 /* If the core file ulimit is too small, the system will first
378 omit the data segment, then omit the stack, then decline to
379 dump core altogether (as far as I know UBLOCK_VALID and LE_VALID
380 are always set) (this is based on experimentation on AIX 3.2).
381 Now, the thing is that GDB users will be surprised
382 if segments just silently don't appear (well, maybe they would
383 think to check "info files", I don't know).
385 For the data segment, we have no choice but to keep going if it's
386 not there, since the default behavior is not to dump it (regardless
387 of the ulimit, it's based on SA_FULLDUMP). But for the stack segment,
388 if it's not there, we refuse to have anything to do with this core
389 file. The usefulness of a core dump without a stack segment is pretty
390 limited anyway. */
392 if (!(c_flag & UBLOCK_VALID)
393 || !(c_flag & LE_VALID))
395 bfd_set_error (bfd_error_wrong_format);
396 return NULL;
399 if (!(c_flag & USTACK_VALID))
401 bfd_set_error (bfd_error_file_truncated);
402 return NULL;
405 /* Don't check the core file size for a full core, AIX 4.1 includes
406 additional shared library sections in a full core. */
407 if (!(c_flag & (FULL_CORE | CORE_TRUNC)))
409 /* If the size is wrong, it means we're misinterpreting something. */
410 if (c_stack + (file_ptr) c_size != statbuf.st_size)
412 bfd_set_error (bfd_error_wrong_format);
413 return NULL;
417 /* Sanity check on the c_tab field. */
418 if (!CORE_NEW (core) && (c_loader < (file_ptr) sizeof core.old ||
419 c_loader >= statbuf.st_size ||
420 c_loader >= c_stack))
422 bfd_set_error (bfd_error_wrong_format);
423 return NULL;
426 /* Issue warning if the core file was truncated during writing. */
427 if (c_flag & CORE_TRUNC)
428 (*_bfd_error_handler) (_("%s: warning core file truncated"),
429 bfd_get_filename (abfd));
431 /* Allocate core file header. */
432 size = CORE_NEW (core) ? sizeof (core.new) : sizeof (core.old);
433 tmpptr = (char *) bfd_zalloc (abfd, (bfd_size_type) size);
434 if (!tmpptr)
435 return NULL;
437 /* Copy core file header. */
438 memcpy (tmpptr, &core, size);
439 set_tdata (abfd, tmpptr);
441 /* Set architecture. */
442 if (CORE_NEW (core))
444 enum bfd_architecture arch;
445 unsigned long mach;
447 switch (CNEW_IMPL (core.new))
449 case POWER_RS1:
450 case POWER_RSC:
451 case POWER_RS2:
452 arch = bfd_arch_rs6000;
453 mach = bfd_mach_rs6k;
454 break;
455 default:
456 arch = bfd_arch_powerpc;
457 mach = bfd_mach_ppc;
458 break;
460 bfd_default_set_arch_mach (abfd, arch, mach);
463 /* .stack section. */
464 if (!make_bfd_asection (abfd, ".stack",
465 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
466 c_size, c_stackend - c_size, c_stack))
467 goto fail;
469 /* .reg section for all registers. */
470 if (!make_bfd_asection (abfd, ".reg",
471 SEC_HAS_CONTENTS,
472 c_regsize, (bfd_vma) 0, c_regoff))
473 goto fail;
475 /* .ldinfo section.
476 To actually find out how long this section is in this particular
477 core dump would require going down the whole list of struct ld_info's.
478 See if we can just fake it. */
479 if (!make_bfd_asection (abfd, ".ldinfo",
480 SEC_HAS_CONTENTS,
481 c_lsize, (bfd_vma) 0, c_loader))
482 goto fail;
484 #ifndef CORE_VERSION_1
485 /* .data section if present.
486 AIX 3 dumps the complete data section and sets FULL_CORE if the
487 ulimit is large enough, otherwise the data section is omitted.
488 AIX 4 sets FULL_CORE even if the core file is truncated, we have
489 to examine core.c_datasize below to find out the actual size of
490 the .data section. */
491 if (c_flag & FULL_CORE)
493 if (!make_bfd_asection (abfd, ".data",
494 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
495 (bfd_size_type) core.old.c_u.u_dsize,
496 (bfd_vma)
497 CDATA_ADDR (core.old.c_u.u_dsize),
498 c_stack + c_size))
499 goto fail;
501 #endif
503 #ifdef CORE_VERSION_1
504 /* AIX 4 adds data sections from loaded objects to the core file,
505 which can be found by examining ldinfo, and anonymously mmapped
506 regions. */
508 LdInfo ldinfo;
509 bfd_size_type ldi_datasize;
510 file_ptr ldi_core;
511 uint ldi_next;
512 bfd_vma ldi_dataorg;
514 /* Fields from new and old core structures. */
515 bfd_size_type c_datasize, c_vmregions;
516 file_ptr c_data, c_vmm;
518 if (CORE_NEW (core))
520 c_datasize = CNEW_DATASIZE (core.new);
521 c_data = (file_ptr) core.new.c_data;
522 c_vmregions = core.new.c_vmregions;
523 c_vmm = (file_ptr) core.new.c_vmm;
525 else
527 c_datasize = core.old.c_datasize;
528 c_data = (file_ptr) (ptr_to_uint) core.old.c_data;
529 c_vmregions = core.old.c_vmregions;
530 c_vmm = (file_ptr) (ptr_to_uint) core.old.c_vmm;
533 /* .data section from executable. */
534 if (c_datasize)
536 if (!make_bfd_asection (abfd, ".data",
537 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
538 c_datasize,
539 (bfd_vma) CDATA_ADDR (c_datasize),
540 c_data))
541 goto fail;
544 /* .data sections from loaded objects. */
545 if (proc64)
546 size = (int) ((LdInfo *) 0)->l64.ldinfo_filename;
547 else
548 size = (int) ((LdInfo *) 0)->l32.ldinfo_filename;
550 while (1)
552 if (bfd_seek (abfd, c_loader, SEEK_SET) != 0)
553 goto fail;
554 if (bfd_bread (&ldinfo, size, abfd) != size)
555 goto fail;
557 if (proc64)
559 ldi_core = ldinfo.l64.ldinfo_core;
560 ldi_datasize = ldinfo.l64.ldinfo_datasize;
561 ldi_dataorg = (bfd_vma) ldinfo.l64.ldinfo_dataorg;
562 ldi_next = ldinfo.l64.ldinfo_next;
564 else
566 ldi_core = ldinfo.l32.ldinfo_core;
567 ldi_datasize = ldinfo.l32.ldinfo_datasize;
568 ldi_dataorg = (bfd_vma) (long) ldinfo.l32.ldinfo_dataorg;
569 ldi_next = ldinfo.l32.ldinfo_next;
572 if (ldi_core)
573 if (!make_bfd_asection (abfd, ".data",
574 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
575 ldi_datasize, ldi_dataorg, ldi_core))
576 goto fail;
578 if (ldi_next == 0)
579 break;
580 c_loader += ldi_next;
583 /* .vmdata sections from anonymously mmapped regions. */
584 if (c_vmregions)
586 bfd_size_type i;
588 if (bfd_seek (abfd, c_vmm, SEEK_SET) != 0)
589 goto fail;
591 for (i = 0; i < c_vmregions; i++)
593 VmInfo vminfo;
594 bfd_size_type vminfo_size;
595 file_ptr vminfo_offset;
596 bfd_vma vminfo_addr;
598 size = CORE_NEW (core) ? sizeof (vminfo.new) : sizeof (vminfo.old);
599 if (bfd_bread (&vminfo, size, abfd) != size)
600 goto fail;
602 if (CORE_NEW (core))
604 vminfo_addr = (bfd_vma) vminfo.new.vminfo_addr;
605 vminfo_size = vminfo.new.vminfo_size;
606 vminfo_offset = vminfo.new.vminfo_offset;
608 else
610 vminfo_addr = (bfd_vma) (long) vminfo.old.vminfo_addr;
611 vminfo_size = vminfo.old.vminfo_size;
612 vminfo_offset = vminfo.old.vminfo_offset;
615 if (vminfo_offset)
616 if (!make_bfd_asection (abfd, ".vmdata",
617 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
618 vminfo_size, vminfo_addr,
619 vminfo_offset))
620 goto fail;
624 #endif
626 return abfd->xvec; /* This is garbage for now. */
628 fail:
629 bfd_release (abfd, abfd->tdata.any);
630 abfd->tdata.any = NULL;
631 bfd_section_list_clear (abfd);
632 return NULL;
635 /* Return `TRUE' if given core is from the given executable. */
637 bfd_boolean
638 rs6000coff_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd)
640 CoreHdr core;
641 bfd_size_type size;
642 char *path, *s;
643 size_t alloc;
644 const char *str1, *str2;
645 bfd_boolean ret;
646 file_ptr c_loader;
648 if (!read_hdr (core_bfd, &core))
649 return FALSE;
651 if (CORE_NEW (core))
652 c_loader = CNEW_LOADER (core.new);
653 else
654 c_loader = (file_ptr) (ptr_to_uint) COLD_LOADER (core.old);
656 if (CORE_NEW (core) && CNEW_PROC64 (core.new))
657 size = (int) ((LdInfo *) 0)->l64.ldinfo_filename;
658 else
659 size = (int) ((LdInfo *) 0)->l32.ldinfo_filename;
661 if (bfd_seek (core_bfd, c_loader + size, SEEK_SET) != 0)
662 return FALSE;
664 alloc = 100;
665 path = bfd_malloc ((bfd_size_type) alloc);
666 if (path == NULL)
667 return FALSE;
668 s = path;
670 while (1)
672 if (bfd_bread (s, (bfd_size_type) 1, core_bfd) != 1)
674 free (path);
675 return FALSE;
677 if (*s == '\0')
678 break;
679 ++s;
680 if (s == path + alloc)
682 char *n;
684 alloc *= 2;
685 n = bfd_realloc (path, (bfd_size_type) alloc);
686 if (n == NULL)
688 free (path);
689 return FALSE;
691 s = n + (path - s);
692 path = n;
696 str1 = strrchr (path, '/');
697 str2 = strrchr (exec_bfd->filename, '/');
699 /* step over character '/' */
700 str1 = str1 != NULL ? str1 + 1 : path;
701 str2 = str2 != NULL ? str2 + 1 : exec_bfd->filename;
703 if (strcmp (str1, str2) == 0)
704 ret = TRUE;
705 else
706 ret = FALSE;
708 free (path);
710 return ret;
713 char *
714 rs6000coff_core_file_failing_command (bfd *abfd)
716 CoreHdr *core = core_hdr (abfd);
717 char *com = CORE_NEW (*core) ?
718 CNEW_COMM (core->new) : COLD_COMM (core->old);
720 if (*com)
721 return com;
722 else
723 return 0;
727 rs6000coff_core_file_failing_signal (bfd *abfd)
729 CoreHdr *core = core_hdr (abfd);
730 return CORE_NEW (*core) ? core->new.c_signo : core->old.c_signo;
733 #endif /* AIX_CORE */