1 /* IBM RS/6000 "XCOFF" back-end for BFD.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 2000, 2001
3 Free Software Foundation, Inc.
4 FIXME: Can someone provide a transliteration of this name into ASCII?
5 Using the following chars caused a compiler warning on HIUX (so I replaced
6 them with octal escapes), and isn't useful without an understanding of what
8 Written by Metin G. Ozisik, Mimi Ph\373\364ng-Th\345o V\365,
10 Archive support from Damon A. Permezel.
11 Contributed by IBM Corporation and Cygnus Support.
13 This file is part of BFD, the Binary File Descriptor library.
15 This program is free software; you can redistribute it and/or modify
16 it under the terms of the GNU General Public License as published by
17 the Free Software Foundation; either version 2 of the License, or
18 (at your option) any later version.
20 This program is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 GNU General Public License for more details.
25 You should have received a copy of the GNU General Public License
26 along with this program; if not, write to the Free Software
27 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
29 /* This port currently only handles reading object files, except when
30 compiled on an RS/6000 host. -- no archive support, no core files.
31 In all cases, it does not support writing.
33 This is in a separate file from coff-rs6000.c, because it includes
34 system include files that conflict with coff/rs6000.h. */
36 /* Internalcoff.h and coffcode.h modify themselves based on this flag. */
37 #define RS6000COFF_C 1
39 /* The AIX 4.1 kernel is obviously compiled with -D_LONG_LONG, so
40 we have to define _LONG_LONG for older versions of gcc to get the
41 proper alignments in the user structure. */
42 #if defined(_AIX41) && !defined(_LONG_LONG)
52 /* AOUTHDR is defined by the above. We need another defn of it, from the
53 system include files. Punt the old one and get us a new name for the
54 typedef in the system include files. */
58 #define AOUTHDR second_AOUTHDR
62 /* ------------------------------------------------------------------------ */
63 /* Support for core file stuff.. */
64 /* ------------------------------------------------------------------------ */
67 #define __LDINFO_PTRACE32__ /* for __ld_info32 */
68 #define __LDINFO_PTRACE64__ /* for __ld_info64 */
71 #include <sys/systemcfg.h>
73 #define core_hdr(bfd) ((CoreHdr *) bfd->tdata.any)
75 /* AIX 4.1 changed the names and locations of a few items in the core file.
76 AIX 4.3 defined an entirely new structure, core_dumpx, but kept support for
77 the previous 4.1 structure, core_dump.
79 AIX_CORE_DUMPX_CORE is defined (by configure) on AIX 4.3+, and
80 CORE_VERSION_1 is defined (by AIX core.h) as 2 on AIX 4.3+ and as 1 on AIX
81 4.1 and 4.2. AIX pre-4.1 (aka 3.x) either doesn't define CORE_VERSION_1
82 or else defines it as 0. */
84 #if defined(CORE_VERSION_1) && !CORE_VERSION_1
85 # undef CORE_VERSION_1
88 /* The following union and macros allow this module to compile on all AIX
89 versions and to handle both core_dumpx and core_dump on 4.3+. CNEW_*()
90 and COLD_*() macros respectively retrieve core_dumpx and core_dump
93 /* Union of 32-bit and 64-bit versions of ld_info. */
97 struct __ld_info32 l32;
98 struct __ld_info64 l64;
105 /* Union of old and new core dump structures. */
108 #ifdef AIX_CORE_DUMPX_CORE
109 struct core_dumpx new; /* new AIX 4.3+ core dump */
111 struct core_dump new; /* for simpler coding */
113 struct core_dump old; /* old AIX 4.2- core dump, still used on
114 4.3+ with appropriate SMIT config */
117 /* Union of old and new vm_info structures. */
119 #ifdef CORE_VERSION_1
121 #ifdef AIX_CORE_DUMPX_CORE
130 /* Return whether CoreHdr C is in new or old format. */
132 #ifdef AIX_CORE_DUMPX_CORE
133 # define CORE_NEW(c) (!(c).old.c_entries)
135 # define CORE_NEW(c) 0
138 /* Return the c_stackorg field from struct core_dumpx C. */
140 #ifdef AIX_CORE_DUMPX_CORE
141 # define CNEW_STACKORG(c) (c).c_stackorg
143 # define CNEW_STACKORG(c) 0
146 /* Return the offset to the loader region from struct core_dump C. */
148 #ifdef AIX_CORE_DUMPX_CORE
149 # define CNEW_LOADER(c) (c).c_loader
151 # define CNEW_LOADER(c) 0
154 /* Return the offset to the loader region from struct core_dump C. */
156 #define COLD_LOADER(c) (c).c_tab
158 /* Return the c_lsize field from struct core_dumpx C. */
160 #ifdef AIX_CORE_DUMPX_CORE
161 # define CNEW_LSIZE(c) (c).c_lsize
163 # define CNEW_LSIZE(c) 0
166 /* Return the c_dataorg field from struct core_dumpx C. */
168 #ifdef AIX_CORE_DUMPX_CORE
169 # define CNEW_DATAORG(c) (c).c_dataorg
171 # define CNEW_DATAORG(c) 0
174 /* Return the c_datasize field from struct core_dumpx C. */
176 #ifdef AIX_CORE_DUMPX_CORE
177 # define CNEW_DATASIZE(c) (c).c_datasize
179 # define CNEW_DATASIZE(c) 0
182 /* Return the c_impl field from struct core_dumpx C. */
184 #ifdef AIX_CORE_DUMPX_CORE
185 # define CNEW_IMPL(c) (c).c_impl
187 # define CNEW_IMPL(c) 0
190 /* Return the command string from struct core_dumpx C. */
192 #ifdef AIX_CORE_DUMPX_CORE
193 # define CNEW_COMM(c) (c).c_u.U_proc.pi_comm
195 # define CNEW_COMM(c) 0
198 /* Return the command string from struct core_dump C. */
200 #ifdef CORE_VERSION_1
201 # define COLD_COMM(c) (c).c_u.U_comm
203 # define COLD_COMM(c) (c).c_u.u_comm
206 /* Return the struct __context64 pointer from struct core_dumpx C. */
208 #ifdef AIX_CORE_DUMPX_CORE
209 # define CNEW_CONTEXT64(c) (c).c_flt.hctx.r64
211 # define CNEW_CONTEXT64(c) c
214 /* Return the struct mstsave pointer from struct core_dumpx C. */
216 #ifdef AIX_CORE_DUMPX_CORE
217 # define CNEW_MSTSAVE(c) (c).c_flt.hctx.r32
219 # define CNEW_MSTSAVE(c) c
222 /* Return the struct mstsave pointer from struct core_dump C. */
224 #ifdef CORE_VERSION_1
225 # define COLD_MSTSAVE(c) (c).c_mst
227 # define COLD_MSTSAVE(c) (c).c_u.u_save
230 /* Return whether struct core_dumpx is from a 64-bit process. */
232 #ifdef AIX_CORE_DUMPX_CORE
233 # define CNEW_PROC64(c) IS_PROC64(&(c).c_u.U_proc)
235 # define CNEW_PROC64(c) 0
238 /* Magic end-of-stack addresses for old core dumps. This is _very_ fragile,
239 but I don't see any easy way to get that info right now. */
241 #ifdef CORE_VERSION_1
242 # define COLD_STACKEND 0x2ff23000
244 # define COLD_STACKEND 0x2ff80000
247 /* Size of the leading portion that old and new core dump structures have in
249 #define CORE_COMMONSZ ((int) &((struct core_dump *) 0)->c_entries \
250 + sizeof (((struct core_dump *) 0)->c_entries))
252 /* Try to read into CORE the header from the core file associated with ABFD.
256 read_hdr (bfd *abfd, CoreHdr *core)
260 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
263 /* Read the leading portion that old and new core dump structures have in
265 if (bfd_read (core, CORE_COMMONSZ, 1, abfd) != CORE_COMMONSZ)
268 /* Read the trailing portion of the structure. */
269 size = CORE_NEW (*core) ? sizeof (core->new) : sizeof (core->old)
271 return bfd_read ((char *) core + CORE_COMMONSZ, size, 1, abfd) == size;
275 make_bfd_asection (abfd, name, flags, _raw_size, vma, filepos)
279 bfd_size_type _raw_size;
285 asect = bfd_make_section_anyway (abfd, name);
289 asect->flags = flags;
290 asect->_raw_size = _raw_size;
292 asect->filepos = filepos;
293 asect->alignment_power = 8;
298 /* Decide if a given bfd represents a `core' file or not. There really is no
299 magic number or anything like, in rs6000coff. */
302 rs6000coff_core_p (abfd)
310 /* Values from new and old core structures. */
312 file_ptr c_stack, c_regoff, c_loader;
313 bfd_size_type c_size, c_regsize, c_lsize;
318 if (!read_hdr (abfd, &core))
320 if (bfd_get_error () != bfd_error_system_call)
321 bfd_set_error (bfd_error_wrong_format);
325 /* Copy fields from new or old core structure. */
328 c_flag = core.new.c_flag;
329 c_stack = (file_ptr) core.new.c_stack;
330 c_size = core.new.c_size;
331 c_stackend = CNEW_STACKORG (core.new) + c_size;
332 c_lsize = CNEW_LSIZE (core.new);
333 c_loader = CNEW_LOADER (core.new);
334 proc64 = CNEW_PROC64 (core.new);
338 c_flag = core.old.c_flag;
339 c_stack = (file_ptr) core.old.c_stack;
340 c_size = core.old.c_size;
341 c_stackend = COLD_STACKEND;
343 c_loader = (file_ptr) COLD_LOADER (core.old);
349 c_regsize = sizeof (CNEW_CONTEXT64 (core.new));
350 c_regptr = &CNEW_CONTEXT64 (core.new);
352 else if (CORE_NEW (core))
354 c_regsize = sizeof (CNEW_MSTSAVE (core.new));
355 c_regptr = &CNEW_MSTSAVE (core.new);
359 c_regsize = sizeof (COLD_MSTSAVE (core.old));
360 c_regptr = &COLD_MSTSAVE (core.old);
362 c_regoff = (char *) c_regptr - (char *) &core;
364 if (bfd_stat (abfd, &statbuf) < 0)
366 bfd_set_error (bfd_error_system_call);
370 /* If the core file ulimit is too small, the system will first
371 omit the data segment, then omit the stack, then decline to
372 dump core altogether (as far as I know UBLOCK_VALID and LE_VALID
373 are always set) (this is based on experimentation on AIX 3.2).
374 Now, the thing is that GDB users will be surprised
375 if segments just silently don't appear (well, maybe they would
376 think to check "info files", I don't know).
378 For the data segment, we have no choice but to keep going if it's
379 not there, since the default behavior is not to dump it (regardless
380 of the ulimit, it's based on SA_FULLDUMP). But for the stack segment,
381 if it's not there, we refuse to have anything to do with this core
382 file. The usefulness of a core dump without a stack segment is pretty
385 if (!(c_flag & UBLOCK_VALID)
386 || !(c_flag & LE_VALID))
388 bfd_set_error (bfd_error_wrong_format);
392 if (!(c_flag & USTACK_VALID))
394 bfd_set_error (bfd_error_file_truncated);
398 /* Don't check the core file size for a full core, AIX 4.1 includes
399 additional shared library sections in a full core. */
400 if (!(c_flag & (FULL_CORE | CORE_TRUNC)))
402 /* If the size is wrong, it means we're misinterpreting something. */
403 if (c_stack + (file_ptr) c_size != statbuf.st_size)
405 bfd_set_error (bfd_error_wrong_format);
410 /* Sanity check on the c_tab field. */
411 if (!CORE_NEW (core) && (c_loader < (file_ptr) sizeof core.old ||
412 c_loader >= statbuf.st_size ||
413 c_loader >= c_stack))
415 bfd_set_error (bfd_error_wrong_format);
419 /* Issue warning if the core file was truncated during writing. */
420 if (c_flag & CORE_TRUNC)
421 (*_bfd_error_handler) (_("%s: warning core file truncated"),
422 bfd_get_filename (abfd));
424 /* Allocate core file header. */
425 size = CORE_NEW (core) ? sizeof (core.new) : sizeof (core.old);
426 tmpptr = (char *) bfd_zalloc (abfd, size);
430 /* Copy core file header. */
431 memcpy (tmpptr, &core, size);
432 set_tdata (abfd, tmpptr);
434 /* Set architecture. */
437 enum bfd_architecture arch;
440 switch (CNEW_IMPL (core.new))
445 arch = bfd_arch_rs6000;
446 mach = bfd_mach_rs6k;
449 arch = bfd_arch_powerpc;
453 bfd_default_set_arch_mach (abfd, arch, mach);
456 /* .stack section. */
457 if (!make_bfd_asection (abfd, ".stack",
458 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
459 c_size, c_stackend - c_size, c_stack))
462 /* .reg section for all registers. */
463 if (!make_bfd_asection (abfd, ".reg",
465 c_regsize, (bfd_vma) 0, c_regoff))
469 To actually find out how long this section is in this particular
470 core dump would require going down the whole list of struct ld_info's.
471 See if we can just fake it. */
472 if (!make_bfd_asection (abfd, ".ldinfo",
474 c_lsize, (bfd_vma) 0, c_loader))
477 #ifndef CORE_VERSION_1
478 /* .data section if present.
479 AIX 3 dumps the complete data section and sets FULL_CORE if the
480 ulimit is large enough, otherwise the data section is omitted.
481 AIX 4 sets FULL_CORE even if the core file is truncated, we have
482 to examine core.c_datasize below to find out the actual size of
483 the .data section. */
484 if (c_flag & FULL_CORE)
486 if (!make_bfd_asection (abfd, ".data",
487 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
488 (bfd_size_type) core.old.c_u.u_dsize,
490 CDATA_ADDR (core.old.c_u.u_dsize),
496 #ifdef CORE_VERSION_1
497 /* AIX 4 adds data sections from loaded objects to the core file,
498 which can be found by examining ldinfo, and anonymously mmapped
502 bfd_size_type ldi_datasize;
507 /* Fields from new and old core structures. */
508 bfd_size_type c_datasize, c_vmregions;
509 file_ptr c_data, c_vmm;
513 c_datasize = CNEW_DATASIZE (core.new);
514 c_data = (file_ptr) core.new.c_data;
515 c_vmregions = core.new.c_vmregions;
516 c_vmm = (file_ptr) core.new.c_vmm;
520 c_datasize = core.old.c_datasize;
521 c_data = (file_ptr) core.old.c_data;
522 c_vmregions = core.old.c_vmregions;
523 c_vmm = (file_ptr) core.old.c_vmm;
526 /* .data section from executable. */
529 if (!make_bfd_asection (abfd, ".data",
530 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
532 (bfd_vma) CDATA_ADDR (c_datasize),
537 /* .data sections from loaded objects. */
539 size = (int) ((LdInfo *) 0)->l64.ldinfo_filename;
541 size = (int) ((LdInfo *) 0)->l32.ldinfo_filename;
545 if (bfd_seek (abfd, c_loader, SEEK_SET) != 0)
547 if (bfd_read (&ldinfo, size, 1, abfd) != size)
552 ldi_core = ldinfo.l64.ldinfo_core;
553 ldi_datasize = ldinfo.l64.ldinfo_datasize;
554 ldi_dataorg = (bfd_vma) ldinfo.l64.ldinfo_dataorg;
555 ldi_next = ldinfo.l64.ldinfo_next;
559 ldi_core = ldinfo.l32.ldinfo_core;
560 ldi_datasize = ldinfo.l32.ldinfo_datasize;
561 ldi_dataorg = (bfd_vma) (long) ldinfo.l32.ldinfo_dataorg;
562 ldi_next = ldinfo.l32.ldinfo_next;
566 if (!make_bfd_asection (abfd, ".data",
567 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
568 ldi_datasize, ldi_dataorg, ldi_core))
573 c_loader += ldi_next;
576 /* .vmdata sections from anonymously mmapped regions. */
581 if (bfd_seek (abfd, c_vmm, SEEK_SET) != 0)
584 for (i = 0; i < c_vmregions; i++)
587 bfd_size_type vminfo_size;
588 file_ptr vminfo_offset;
591 size = CORE_NEW (core) ? sizeof (vminfo.new) : sizeof (vminfo.old);
592 if (bfd_read (&vminfo, size, 1, abfd) != size)
597 vminfo_addr = (bfd_vma) vminfo.new.vminfo_addr;
598 vminfo_size = vminfo.new.vminfo_size;
599 vminfo_offset = vminfo.new.vminfo_offset;
603 vminfo_addr = (bfd_vma) (long) vminfo.old.vminfo_addr;
604 vminfo_size = vminfo.old.vminfo_size;
605 vminfo_offset = vminfo.old.vminfo_offset;
609 if (!make_bfd_asection (abfd, ".vmdata",
610 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
611 vminfo_size, vminfo_addr,
619 return abfd->xvec; /* This is garbage for now. */
622 /* Return `true' if given core is from the given executable. */
625 rs6000coff_core_file_matches_executable_p (core_bfd, exec_bfd)
633 const char *str1, *str2;
637 if (!read_hdr (core_bfd, &core))
641 c_loader = CNEW_LOADER (core.new);
643 c_loader = (file_ptr) COLD_LOADER (core.old);
645 if (CORE_NEW (core) && CNEW_PROC64 (core.new))
646 size = (int) ((LdInfo *) 0)->l64.ldinfo_filename;
648 size = (int) ((LdInfo *) 0)->l32.ldinfo_filename;
650 if (bfd_seek (core_bfd, c_loader + size, SEEK_SET) != 0)
654 path = bfd_malloc (alloc);
661 if (bfd_read (s, 1, 1, core_bfd) != 1)
669 if (s == path + alloc)
674 n = bfd_realloc (path, alloc);
685 str1 = strrchr (path, '/');
686 str2 = strrchr (exec_bfd->filename, '/');
688 /* step over character '/' */
689 str1 = str1 != NULL ? str1 + 1 : path;
690 str2 = str2 != NULL ? str2 + 1 : exec_bfd->filename;
692 if (strcmp (str1, str2) == 0)
703 rs6000coff_core_file_failing_command (abfd)
706 CoreHdr *core = core_hdr (abfd);
707 char *com = CORE_NEW (*core) ?
708 CNEW_COMM (core->new) : COLD_COMM (core->old);
717 rs6000coff_core_file_failing_signal (abfd)
720 CoreHdr *core = core_hdr (abfd);
721 return CORE_NEW (*core) ? core->new.c_signo : core->old.c_signo;
724 #endif /* AIX_CORE */