1 /* IBM RS/6000 "XCOFF" back-end for BFD.
2 Copyright (C) 1990-2014 Free Software Foundation, Inc.
3 Written by Metin G. Ozisik, Mimi Phuong-Thao Vo, and John Gilmore.
4 Archive support from Damon A. Permezel.
5 Contributed by IBM Corporation and Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
25 /* This port currently only handles reading object files, except when
26 compiled on an RS/6000 host. -- no archive support, no core files.
27 In all cases, it does not support writing.
29 This is in a separate file from coff-rs6000.c, because it includes
30 system include files that conflict with coff/rs6000.h. */
32 /* Internalcoff.h and coffcode.h modify themselves based on this flag. */
33 #define RS6000COFF_C 1
35 /* The AIX 4.1 kernel is obviously compiled with -D_LONG_LONG, so
36 we have to define _LONG_LONG for older versions of gcc to get the
37 proper alignments in the user structure. */
38 #if defined(_AIX41) && !defined(_LONG_LONG)
48 /* AOUTHDR is defined by the above. We need another defn of it, from the
49 system include files. Punt the old one and get us a new name for the
50 typedef in the system include files. */
54 #define AOUTHDR second_AOUTHDR
58 /* ------------------------------------------------------------------------ */
59 /* Support for core file stuff.. */
60 /* ------------------------------------------------------------------------ */
63 #define __LDINFO_PTRACE32__ /* for __ld_info32 */
64 #define __LDINFO_PTRACE64__ /* for __ld_info64 */
67 #include <sys/systemcfg.h>
69 /* Borrowed from <sys/inttypes.h> on recent AIX versions. */
70 typedef unsigned long ptr_to_uint;
72 #define core_hdr(bfd) ((CoreHdr *) bfd->tdata.any)
74 /* AIX 4.1 changed the names and locations of a few items in the core file.
75 AIX 4.3 defined an entirely new structure, core_dumpx, but kept support for
76 the previous 4.1 structure, core_dump.
78 AIX_CORE_DUMPX_CORE is defined (by configure) on AIX 4.3+, and
79 CORE_VERSION_1 is defined (by AIX core.h) as 2 on AIX 4.3+ and as 1 on AIX
80 4.1 and 4.2. AIX pre-4.1 (aka 3.x) either doesn't define CORE_VERSION_1
81 or else defines it as 0. */
83 #if defined(CORE_VERSION_1) && !CORE_VERSION_1
84 # undef CORE_VERSION_1
87 /* The following union and macros allow this module to compile on all AIX
88 versions and to handle both core_dumpx and core_dump on 4.3+. CNEW_*()
89 and COLD_*() macros respectively retrieve core_dumpx and core_dump
92 /* Union of 32-bit and 64-bit versions of ld_info. */
96 struct __ld_info32 l32;
97 struct __ld_info64 l64;
104 /* Union of old and new core dump structures. */
107 #ifdef AIX_CORE_DUMPX_CORE
108 struct core_dumpx new_dump; /* new AIX 4.3+ core dump */
110 struct core_dump new_dump; /* for simpler coding */
112 struct core_dump old; /* old AIX 4.2- core dump, still used on
113 4.3+ with appropriate SMIT config */
116 /* Union of old and new vm_info structures. */
118 #ifdef CORE_VERSION_1
120 #ifdef AIX_CORE_DUMPX_CORE
121 struct vm_infox new_dump;
123 struct vm_info new_dump;
129 /* Return whether CoreHdr C is in new or old format. */
131 #ifdef AIX_CORE_DUMPX_CORE
132 # define CORE_NEW(c) (!(c).old.c_entries)
134 # define CORE_NEW(c) 0
137 /* Return whether CoreHdr C usese core_dumpxx structure.
139 FIXME: the core file format version number used here definitely indicates
140 that struct core_dumpxx should be used to represent the core file header,
141 but that may not be the only such format version number. */
144 # define CORE_DUMPXX_VERSION 267312562
145 # define CNEW_IS_CORE_DUMPXX(c) ((c).new_dump.c_version == CORE_DUMPXX_VERSION)
147 # define CNEW_IS_CORE_DUMPXX(c) 0
150 /* Return the c_stackorg field from struct core_dumpx C. */
152 #ifdef AIX_CORE_DUMPX_CORE
153 # define CNEW_STACKORG(c) (c).c_stackorg
155 # define CNEW_STACKORG(c) 0
158 /* Return the offset to the loader region from struct core_dump C. */
160 #ifdef AIX_CORE_DUMPX_CORE
161 # define CNEW_LOADER(c) (c).c_loader
163 # define CNEW_LOADER(c) 0
166 /* Return the offset to the loader region from struct core_dump C. */
168 #define COLD_LOADER(c) (c).c_tab
170 /* Return the c_lsize field from struct core_dumpx C. */
172 #ifdef AIX_CORE_DUMPX_CORE
173 # define CNEW_LSIZE(c) (c).c_lsize
175 # define CNEW_LSIZE(c) 0
178 /* Return the c_dataorg field from struct core_dumpx C. */
180 #ifdef AIX_CORE_DUMPX_CORE
181 # define CNEW_DATAORG(c) (c).c_dataorg
183 # define CNEW_DATAORG(c) 0
186 /* Return the c_datasize field from struct core_dumpx C. */
188 #ifdef AIX_CORE_DUMPX_CORE
189 # define CNEW_DATASIZE(c) (c).c_datasize
191 # define CNEW_DATASIZE(c) 0
194 /* Return the c_impl field from struct core_dumpx C. */
196 #if defined (HAVE_ST_C_IMPL) || defined (AIX_5_CORE)
197 # define CNEW_IMPL(c) (c).c_impl
199 # define CNEW_IMPL(c) 0
202 /* Return the command string from struct core_dumpx C. */
204 #ifdef AIX_CORE_DUMPX_CORE
205 # define CNEW_COMM(c) (c).c_u.U_proc.pi_comm
207 # define CNEW_COMM(c) 0
210 /* Return the command string from struct core_dump C. */
212 #ifdef CORE_VERSION_1
213 # define COLD_COMM(c) (c).c_u.U_comm
215 # define COLD_COMM(c) (c).c_u.u_comm
218 /* Return the struct __context64 pointer from struct core_dumpx C. */
220 #ifdef AIX_CORE_DUMPX_CORE
221 # define CNEW_CONTEXT64(c) (c).c_flt.hctx.r64
223 # define CNEW_CONTEXT64(c) c
226 /* Return the struct mstsave pointer from struct core_dumpx C. */
228 #ifdef AIX_CORE_DUMPX_CORE
229 # define CNEW_MSTSAVE(c) (c).c_flt.hctx.r32
231 # define CNEW_MSTSAVE(c) c
234 /* Return the struct mstsave pointer from struct core_dump C. */
236 #ifdef CORE_VERSION_1
237 # define COLD_MSTSAVE(c) (c).c_mst
239 # define COLD_MSTSAVE(c) (c).c_u.u_save
242 /* Return whether struct core_dumpx is from a 64-bit process. */
244 #ifdef AIX_CORE_DUMPX_CORE
245 # define CNEW_PROC64(c) IS_PROC64(&(c).c_u.U_proc)
247 # define CNEW_PROC64(c) 0
250 /* Magic end-of-stack addresses for old core dumps. This is _very_ fragile,
251 but I don't see any easy way to get that info right now. */
253 #ifdef CORE_VERSION_1
254 # define COLD_STACKEND 0x2ff23000
256 # define COLD_STACKEND 0x2ff80000
259 /* Size of the leading portion that old and new core dump structures have in
261 #define CORE_COMMONSZ ((int) &((struct core_dump *) 0)->c_entries \
262 + sizeof (((struct core_dump *) 0)->c_entries))
264 /* Define prototypes for certain functions, to avoid a compiler warning
265 saying that they are missing. */
267 const bfd_target * rs6000coff_core_p (bfd *abfd);
268 bfd_boolean rs6000coff_core_file_matches_executable_p (bfd *core_bfd,
270 char * rs6000coff_core_file_failing_command (bfd *abfd);
271 int rs6000coff_core_file_failing_signal (bfd *abfd);
273 /* Try to read into CORE the header from the core file associated with ABFD.
277 read_hdr (bfd *abfd, CoreHdr *core)
281 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
284 /* Read the leading portion that old and new core dump structures have in
286 size = CORE_COMMONSZ;
287 if (bfd_bread (core, size, abfd) != size)
290 /* Read the trailing portion of the structure. */
291 if (CORE_NEW (*core))
292 size = sizeof (core->new_dump);
294 size = sizeof (core->old);
295 size -= CORE_COMMONSZ;
296 return bfd_bread ((char *) core + CORE_COMMONSZ, size, abfd) == size;
300 make_bfd_asection (bfd *abfd, const char *name, flagword flags,
301 bfd_size_type size, bfd_vma vma, file_ptr filepos)
305 asect = bfd_make_section_anyway_with_flags (abfd, name, flags);
311 asect->filepos = filepos;
312 asect->alignment_power = 8;
317 /* Decide if a given bfd represents a `core' file or not. There really is no
318 magic number or anything like, in rs6000coff. */
321 rs6000coff_core_p (bfd *abfd)
328 /* Values from new and old core structures. */
330 file_ptr c_stack, c_regoff, c_loader;
331 bfd_size_type c_size, c_regsize, c_lsize;
336 if (!read_hdr (abfd, &core))
338 if (bfd_get_error () != bfd_error_system_call)
339 bfd_set_error (bfd_error_wrong_format);
343 /* This isn't the right handler for 64-bit core files on AIX 5.x. */
344 if (CORE_NEW (core) && CNEW_IS_CORE_DUMPXX (core))
346 bfd_set_error (bfd_error_wrong_format);
350 /* Copy fields from new or old core structure. */
353 c_flag = core.new_dump.c_flag;
354 c_stack = (file_ptr) core.new_dump.c_stack;
355 c_size = core.new_dump.c_size;
356 c_stackend = CNEW_STACKORG (core.new_dump) + c_size;
357 c_lsize = CNEW_LSIZE (core.new_dump);
358 c_loader = CNEW_LOADER (core.new_dump);
359 proc64 = CNEW_PROC64 (core.new_dump);
363 c_flag = core.old.c_flag;
364 c_stack = (file_ptr) (ptr_to_uint) core.old.c_stack;
365 c_size = core.old.c_size;
366 c_stackend = COLD_STACKEND;
368 c_loader = (file_ptr) (ptr_to_uint) COLD_LOADER (core.old);
374 c_regsize = sizeof (CNEW_CONTEXT64 (core.new_dump));
375 c_regptr = &CNEW_CONTEXT64 (core.new_dump);
377 else if (CORE_NEW (core))
379 c_regsize = sizeof (CNEW_MSTSAVE (core.new_dump));
380 c_regptr = &CNEW_MSTSAVE (core.new_dump);
384 c_regsize = sizeof (COLD_MSTSAVE (core.old));
385 c_regptr = &COLD_MSTSAVE (core.old);
387 c_regoff = (char *) c_regptr - (char *) &core;
389 if (bfd_stat (abfd, &statbuf) < 0)
391 bfd_set_error (bfd_error_system_call);
395 /* If the core file ulimit is too small, the system will first
396 omit the data segment, then omit the stack, then decline to
397 dump core altogether (as far as I know UBLOCK_VALID and LE_VALID
398 are always set) (this is based on experimentation on AIX 3.2).
399 Now, the thing is that GDB users will be surprised
400 if segments just silently don't appear (well, maybe they would
401 think to check "info files", I don't know).
403 For the data segment, we have no choice but to keep going if it's
404 not there, since the default behavior is not to dump it (regardless
405 of the ulimit, it's based on SA_FULLDUMP). But for the stack segment,
406 if it's not there, we refuse to have anything to do with this core
407 file. The usefulness of a core dump without a stack segment is pretty
410 if (!(c_flag & UBLOCK_VALID)
411 || !(c_flag & LE_VALID))
413 bfd_set_error (bfd_error_wrong_format);
417 if (!(c_flag & USTACK_VALID))
419 bfd_set_error (bfd_error_file_truncated);
423 /* Don't check the core file size for a full core, AIX 4.1 includes
424 additional shared library sections in a full core. */
425 if (!(c_flag & (FULL_CORE | CORE_TRUNC)))
427 /* If the size is wrong, it means we're misinterpreting something. */
428 if (c_stack + (file_ptr) c_size != statbuf.st_size)
430 bfd_set_error (bfd_error_wrong_format);
435 /* Sanity check on the c_tab field. */
436 if (!CORE_NEW (core) && (c_loader < (file_ptr) sizeof core.old ||
437 c_loader >= statbuf.st_size ||
438 c_loader >= c_stack))
440 bfd_set_error (bfd_error_wrong_format);
444 /* Issue warning if the core file was truncated during writing. */
445 if (c_flag & CORE_TRUNC)
446 (*_bfd_error_handler) (_("%s: warning core file truncated"),
447 bfd_get_filename (abfd));
449 /* Allocate core file header. */
450 size = CORE_NEW (core) ? sizeof (core.new_dump) : sizeof (core.old);
451 tmpptr = (char *) bfd_zalloc (abfd, (bfd_size_type) size);
455 /* Copy core file header. */
456 memcpy (tmpptr, &core, size);
457 set_tdata (abfd, tmpptr);
459 /* Set architecture. */
462 enum bfd_architecture arch;
465 switch (CNEW_IMPL (core.new_dump))
470 arch = bfd_arch_rs6000;
471 mach = bfd_mach_rs6k;
474 arch = bfd_arch_powerpc;
478 bfd_default_set_arch_mach (abfd, arch, mach);
481 /* .stack section. */
482 if (!make_bfd_asection (abfd, ".stack",
483 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
484 c_size, c_stackend - c_size, c_stack))
487 /* .reg section for all registers. */
488 if (!make_bfd_asection (abfd, ".reg",
490 c_regsize, (bfd_vma) 0, c_regoff))
494 To actually find out how long this section is in this particular
495 core dump would require going down the whole list of struct ld_info's.
496 See if we can just fake it. */
497 if (!make_bfd_asection (abfd, ".ldinfo",
499 c_lsize, (bfd_vma) 0, c_loader))
502 #ifndef CORE_VERSION_1
503 /* .data section if present.
504 AIX 3 dumps the complete data section and sets FULL_CORE if the
505 ulimit is large enough, otherwise the data section is omitted.
506 AIX 4 sets FULL_CORE even if the core file is truncated, we have
507 to examine core.c_datasize below to find out the actual size of
508 the .data section. */
509 if (c_flag & FULL_CORE)
511 if (!make_bfd_asection (abfd, ".data",
512 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
513 (bfd_size_type) core.old.c_u.u_dsize,
515 CDATA_ADDR (core.old.c_u.u_dsize),
521 #ifdef CORE_VERSION_1
522 /* AIX 4 adds data sections from loaded objects to the core file,
523 which can be found by examining ldinfo, and anonymously mmapped
527 bfd_size_type ldi_datasize;
532 /* Fields from new and old core structures. */
533 bfd_size_type c_datasize, c_vmregions;
534 file_ptr c_data, c_vmm;
538 c_datasize = CNEW_DATASIZE (core.new_dump);
539 c_data = (file_ptr) core.new_dump.c_data;
540 c_vmregions = core.new_dump.c_vmregions;
541 c_vmm = (file_ptr) core.new_dump.c_vmm;
545 c_datasize = core.old.c_datasize;
546 c_data = (file_ptr) (ptr_to_uint) core.old.c_data;
547 c_vmregions = core.old.c_vmregions;
548 c_vmm = (file_ptr) (ptr_to_uint) core.old.c_vmm;
551 /* .data section from executable. */
554 if (!make_bfd_asection (abfd, ".data",
555 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
557 (bfd_vma) CDATA_ADDR (c_datasize),
562 /* .data sections from loaded objects. */
564 size = (int) ((LdInfo *) 0)->l64.ldinfo_filename;
566 size = (int) ((LdInfo *) 0)->l32.ldinfo_filename;
570 if (bfd_seek (abfd, c_loader, SEEK_SET) != 0)
572 if (bfd_bread (&ldinfo, size, abfd) != size)
577 ldi_core = ldinfo.l64.ldinfo_core;
578 ldi_datasize = ldinfo.l64.ldinfo_datasize;
579 ldi_dataorg = (bfd_vma) ldinfo.l64.ldinfo_dataorg;
580 ldi_next = ldinfo.l64.ldinfo_next;
584 ldi_core = ldinfo.l32.ldinfo_core;
585 ldi_datasize = ldinfo.l32.ldinfo_datasize;
586 ldi_dataorg = (bfd_vma) (long) ldinfo.l32.ldinfo_dataorg;
587 ldi_next = ldinfo.l32.ldinfo_next;
591 if (!make_bfd_asection (abfd, ".data",
592 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
593 ldi_datasize, ldi_dataorg, ldi_core))
598 c_loader += ldi_next;
601 /* .vmdata sections from anonymously mmapped regions. */
606 if (bfd_seek (abfd, c_vmm, SEEK_SET) != 0)
609 for (i = 0; i < c_vmregions; i++)
612 bfd_size_type vminfo_size;
613 file_ptr vminfo_offset;
616 size = CORE_NEW (core) ? sizeof (vminfo.new_dump) : sizeof (vminfo.old);
617 if (bfd_bread (&vminfo, size, abfd) != size)
622 vminfo_addr = (bfd_vma) vminfo.new_dump.vminfo_addr;
623 vminfo_size = vminfo.new_dump.vminfo_size;
624 vminfo_offset = vminfo.new_dump.vminfo_offset;
628 vminfo_addr = (bfd_vma) (long) vminfo.old.vminfo_addr;
629 vminfo_size = vminfo.old.vminfo_size;
630 vminfo_offset = vminfo.old.vminfo_offset;
634 if (!make_bfd_asection (abfd, ".vmdata",
635 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
636 vminfo_size, vminfo_addr,
644 return abfd->xvec; /* This is garbage for now. */
647 bfd_release (abfd, abfd->tdata.any);
648 abfd->tdata.any = NULL;
649 bfd_section_list_clear (abfd);
653 /* Return `TRUE' if given core is from the given executable. */
656 rs6000coff_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd)
662 const char *str1, *str2;
666 if (!read_hdr (core_bfd, &core))
670 c_loader = CNEW_LOADER (core.new_dump);
672 c_loader = (file_ptr) (ptr_to_uint) COLD_LOADER (core.old);
674 if (CORE_NEW (core) && CNEW_PROC64 (core.new_dump))
675 size = (int) ((LdInfo *) 0)->l64.ldinfo_filename;
677 size = (int) ((LdInfo *) 0)->l32.ldinfo_filename;
679 if (bfd_seek (core_bfd, c_loader + size, SEEK_SET) != 0)
683 path = bfd_malloc ((bfd_size_type) alloc);
690 if (bfd_bread (s, (bfd_size_type) 1, core_bfd) != 1)
698 if (s == path + alloc)
703 n = bfd_realloc (path, (bfd_size_type) alloc);
714 str1 = strrchr (path, '/');
715 str2 = strrchr (exec_bfd->filename, '/');
717 /* step over character '/' */
718 str1 = str1 != NULL ? str1 + 1 : path;
719 str2 = str2 != NULL ? str2 + 1 : exec_bfd->filename;
721 if (strcmp (str1, str2) == 0)
732 rs6000coff_core_file_failing_command (bfd *abfd)
734 CoreHdr *core = core_hdr (abfd);
735 char *com = CORE_NEW (*core) ?
736 CNEW_COMM (core->new_dump) : COLD_COMM (core->old);
745 rs6000coff_core_file_failing_signal (bfd *abfd)
747 CoreHdr *core = core_hdr (abfd);
748 return CORE_NEW (*core) ? core->new_dump.c_signo : core->old.c_signo;
751 #endif /* AIX_CORE */