bfd/rs6000-core.c

   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
   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.
  13
  14    This file is part of BFD, the Binary File Descriptor library.
  15
  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.
  20
  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.
  25
  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.  */
  29
  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.
  33
  34    This is in a separate file from coff-rs6000.c, because it includes
  35    system include files that conflict with coff/rs6000.h.  */
  36
  37 /* Internalcoff.h and coffcode.h modify themselves based on this flag.  */
  38 #define RS6000COFF_C 1
  39
  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
  46
  47 #include "bfd.h"
  48 #include "sysdep.h"
  49 #include "libbfd.h"
  50
  51 #ifdef AIX_CORE
  52
  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
  60
  61 #undef  SCNHDR
  62
  63 /* ------------------------------------------------------------------------ */
  64 /*      Support for core file stuff..                                       */
  65 /* ------------------------------------------------------------------------ */
  66
  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>
  73
  74 /* Borrowed from <sys/inttypes.h> on recent AIX versions.  */
  75 typedef unsigned long ptr_to_uint;
  76
  77 #define core_hdr(bfd)           ((CoreHdr *) bfd->tdata.any)
  78
  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.
  82
  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.  */
  87
  88 #if defined(CORE_VERSION_1) && !CORE_VERSION_1
  89 # undef CORE_VERSION_1
  90 #endif
  91
  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.  */
  96
  97 /* Union of 32-bit and 64-bit versions of ld_info.  */
  98
  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;
 108
 109 /* Union of old and new core dump structures.  */
 110
 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;
 120
 121 /* Union of old and new vm_info structures.  */
 122
 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
 133
 134 /* Return whether CoreHdr C is in new or old format.  */
 135
 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
 141
 142 /* Return the c_stackorg field from struct core_dumpx C.  */
 143
 144 #ifdef AIX_CORE_DUMPX_CORE
 145 # define CNEW_STACKORG(c)       (c).c_stackorg
 146 #else
 147 # define CNEW_STACKORG(c)       0
 148 #endif
 149
 150 /* Return the offset to the loader region from struct core_dump C.  */
 151
 152 #ifdef AIX_CORE_DUMPX_CORE
 153 # define CNEW_LOADER(c) (c).c_loader
 154 #else
 155 # define CNEW_LOADER(c) 0
 156 #endif
 157
 158 /* Return the offset to the loader region from struct core_dump C.  */
 159
 160 #define COLD_LOADER(c)  (c).c_tab
 161
 162 /* Return the c_lsize field from struct core_dumpx C.  */
 163
 164 #ifdef AIX_CORE_DUMPX_CORE
 165 # define CNEW_LSIZE(c)  (c).c_lsize
 166 #else
 167 # define CNEW_LSIZE(c)  0
 168 #endif
 169
 170 /* Return the c_dataorg field from struct core_dumpx C.  */
 171
 172 #ifdef AIX_CORE_DUMPX_CORE
 173 # define CNEW_DATAORG(c)        (c).c_dataorg
 174 #else
 175 # define CNEW_DATAORG(c)        0
 176 #endif
 177
 178 /* Return the c_datasize field from struct core_dumpx C.  */
 179
 180 #ifdef AIX_CORE_DUMPX_CORE
 181 # define CNEW_DATASIZE(c)       (c).c_datasize
 182 #else
 183 # define CNEW_DATASIZE(c)       0
 184 #endif
 185
 186 /* Return the c_impl field from struct core_dumpx C.  */
 187
 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
 193
 194 /* Return the command string from struct core_dumpx C.  */
 195
 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
 201
 202 /* Return the command string from struct core_dump C.  */
 203
 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
 209
 210 /* Return the struct __context64 pointer from struct core_dumpx C.  */
 211
 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
 217
 218 /* Return the struct mstsave pointer from struct core_dumpx C.  */
 219
 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
 225
 226 /* Return the struct mstsave pointer from struct core_dump C.  */
 227
 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
 233
 234 /* Return whether struct core_dumpx is from a 64-bit process.  */
 235
 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
 241
 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.  */
 244
 245 #ifdef CORE_VERSION_1
 246 # define COLD_STACKEND  0x2ff23000
 247 #else
 248 # define COLD_STACKEND  0x2ff80000
 249 #endif
 250
 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))
 255
 256 /* Define prototypes for certain functions, to avoid a compiler warning
 257    saying that they are missing.  */
 258
 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);
 264
 265 /* Try to read into CORE the header from the core file associated with ABFD.
 266    Return success.  */
 267
 268 static bfd_boolean
 269 read_hdr (bfd *abfd, CoreHdr *core)
 270 {
 271   bfd_size_type size;
 272
 273   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 274     return FALSE;
 275
 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;
 281
 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;
 289 }
 290
 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)
 294 {
 295   asection *asect;
 296
 297   asect = bfd_make_section_anyway (abfd, name);
 298   if (!asect)
 299     return NULL;
 300
 301   asect->flags = flags;
 302   asect->size = size;
 303   asect->vma = vma;
 304   asect->filepos = filepos;
 305   asect->alignment_power = 8;
 306
 307   return asect;
 308 }
 309
 310 /* Decide if a given bfd represents a `core' file or not. There really is no
 311    magic number or anything like, in rs6000coff.  */
 312
 313 const bfd_target *
 314 rs6000coff_core_p (bfd *abfd)
 315 {
 316   CoreHdr core;
 317   struct stat statbuf;
 318   bfd_size_type size;
 319   char *tmpptr;
 320
 321   /* Values from new and old core structures.  */
 322   int c_flag;
 323   file_ptr c_stack, c_regoff, c_loader;
 324   bfd_size_type c_size, c_regsize, c_lsize;
 325   bfd_vma c_stackend;
 326   void *c_regptr;
 327   int proc64;
 328
 329   if (!read_hdr (abfd, &core))
 330     {
 331       if (bfd_get_error () != bfd_error_system_call)
 332         bfd_set_error (bfd_error_wrong_format);
 333       return NULL;
 334     }
 335
 336   /* Copy fields from new or old core structure.  */
 337   if (CORE_NEW (core))
 338     {
 339       c_flag = core.new.c_flag;
 340       c_stack = (file_ptr) core.new.c_stack;
 341       c_size = core.new.c_size;
 342       c_stackend = CNEW_STACKORG (core.new) + c_size;
 343       c_lsize = CNEW_LSIZE (core.new);
 344       c_loader = CNEW_LOADER (core.new);
 345       proc64 = CNEW_PROC64 (core.new);
 346     }
 347   else
 348     {
 349       c_flag = core.old.c_flag;
 350       c_stack = (file_ptr) (ptr_to_uint) core.old.c_stack;
 351       c_size = core.old.c_size;
 352       c_stackend = COLD_STACKEND;
 353       c_lsize = 0x7ffffff;
 354       c_loader = (file_ptr) (ptr_to_uint) COLD_LOADER (core.old);
 355       proc64 = 0;
 356     }
 357
 358   if (proc64)
 359     {
 360       c_regsize = sizeof (CNEW_CONTEXT64 (core.new));
 361       c_regptr = &CNEW_CONTEXT64 (core.new);
 362     }
 363   else if (CORE_NEW (core))
 364     {
 365       c_regsize = sizeof (CNEW_MSTSAVE (core.new));
 366       c_regptr = &CNEW_MSTSAVE (core.new);
 367     }
 368   else
 369     {
 370       c_regsize = sizeof (COLD_MSTSAVE (core.old));
 371       c_regptr = &COLD_MSTSAVE (core.old);
 372     }
 373   c_regoff = (char *) c_regptr - (char *) &core;
 374
 375   if (bfd_stat (abfd, &statbuf) < 0)
 376     {
 377       bfd_set_error (bfd_error_system_call);
 378       return NULL;
 379     }
 380
 381   /* If the core file ulimit is too small, the system will first
 382      omit the data segment, then omit the stack, then decline to
 383      dump core altogether (as far as I know UBLOCK_VALID and LE_VALID
 384      are always set) (this is based on experimentation on AIX 3.2).
 385      Now, the thing is that GDB users will be surprised
 386      if segments just silently don't appear (well, maybe they would
 387      think to check "info files", I don't know).
 388
 389      For the data segment, we have no choice but to keep going if it's
 390      not there, since the default behavior is not to dump it (regardless
 391      of the ulimit, it's based on SA_FULLDUMP).  But for the stack segment,
 392      if it's not there, we refuse to have anything to do with this core
 393      file.  The usefulness of a core dump without a stack segment is pretty
 394      limited anyway.  */
 395
 396   if (!(c_flag & UBLOCK_VALID)
 397       || !(c_flag & LE_VALID))
 398     {
 399       bfd_set_error (bfd_error_wrong_format);
 400       return NULL;
 401     }
 402
 403   if (!(c_flag & USTACK_VALID))
 404     {
 405       bfd_set_error (bfd_error_file_truncated);
 406       return NULL;
 407     }
 408
 409   /* Don't check the core file size for a full core, AIX 4.1 includes
 410      additional shared library sections in a full core.  */
 411   if (!(c_flag & (FULL_CORE | CORE_TRUNC)))
 412     {
 413       /* If the size is wrong, it means we're misinterpreting something.  */
 414       if (c_stack + (file_ptr) c_size != statbuf.st_size)
 415         {
 416           bfd_set_error (bfd_error_wrong_format);
 417           return NULL;
 418         }
 419     }
 420
 421   /* Sanity check on the c_tab field.  */
 422   if (!CORE_NEW (core) && (c_loader < (file_ptr) sizeof core.old ||
 423                            c_loader >= statbuf.st_size ||
 424                            c_loader >= c_stack))
 425     {
 426       bfd_set_error (bfd_error_wrong_format);
 427       return NULL;
 428     }
 429
 430   /* Issue warning if the core file was truncated during writing.  */
 431   if (c_flag & CORE_TRUNC)
 432     (*_bfd_error_handler) (_("%s: warning core file truncated"),
 433                            bfd_get_filename (abfd));
 434
 435   /* Allocate core file header.  */
 436   size = CORE_NEW (core) ? sizeof (core.new) : sizeof (core.old);
 437   tmpptr = (char *) bfd_zalloc (abfd, (bfd_size_type) size);
 438   if (!tmpptr)
 439     return NULL;
 440
 441   /* Copy core file header.  */
 442   memcpy (tmpptr, &core, size);
 443   set_tdata (abfd, tmpptr);
 444
 445   /* Set architecture.  */
 446   if (CORE_NEW (core))
 447     {
 448       enum bfd_architecture arch;
 449       unsigned long mach;
 450
 451       switch (CNEW_IMPL (core.new))
 452         {
 453         case POWER_RS1:
 454         case POWER_RSC:
 455         case POWER_RS2:
 456           arch = bfd_arch_rs6000;
 457           mach = bfd_mach_rs6k;
 458           break;
 459         default:
 460           arch = bfd_arch_powerpc;
 461           mach = bfd_mach_ppc;
 462           break;
 463         }
 464       bfd_default_set_arch_mach (abfd, arch, mach);
 465     }
 466
 467   /* .stack section.  */
 468   if (!make_bfd_asection (abfd, ".stack",
 469                           SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
 470                           c_size, c_stackend - c_size, c_stack))
 471     goto fail;
 472
 473   /* .reg section for all registers.  */
 474   if (!make_bfd_asection (abfd, ".reg",
 475                           SEC_HAS_CONTENTS,
 476                           c_regsize, (bfd_vma) 0, c_regoff))
 477     goto fail;
 478
 479   /* .ldinfo section.
 480      To actually find out how long this section is in this particular
 481      core dump would require going down the whole list of struct ld_info's.
 482      See if we can just fake it.  */
 483   if (!make_bfd_asection (abfd, ".ldinfo",
 484                           SEC_HAS_CONTENTS,
 485                           c_lsize, (bfd_vma) 0, c_loader))
 486     goto fail;
 487
 488 #ifndef CORE_VERSION_1
 489   /* .data section if present.
 490      AIX 3 dumps the complete data section and sets FULL_CORE if the
 491      ulimit is large enough, otherwise the data section is omitted.
 492      AIX 4 sets FULL_CORE even if the core file is truncated, we have
 493      to examine core.c_datasize below to find out the actual size of
 494      the .data section.  */
 495   if (c_flag & FULL_CORE)
 496     {
 497       if (!make_bfd_asection (abfd, ".data",
 498                               SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
 499                               (bfd_size_type) core.old.c_u.u_dsize,
 500                               (bfd_vma)
 501                                 CDATA_ADDR (core.old.c_u.u_dsize),
 502                               c_stack + c_size))
 503         goto fail;
 504     }
 505 #endif
 506
 507 #ifdef CORE_VERSION_1
 508   /* AIX 4 adds data sections from loaded objects to the core file,
 509      which can be found by examining ldinfo, and anonymously mmapped
 510      regions.  */
 511   {
 512     LdInfo ldinfo;
 513     bfd_size_type ldi_datasize;
 514     file_ptr ldi_core;
 515     uint ldi_next;
 516     bfd_vma ldi_dataorg;
 517
 518     /* Fields from new and old core structures.  */
 519     bfd_size_type c_datasize, c_vmregions;
 520     file_ptr c_data, c_vmm;
 521
 522     if (CORE_NEW (core))
 523       {
 524         c_datasize = CNEW_DATASIZE (core.new);
 525         c_data = (file_ptr) core.new.c_data;
 526         c_vmregions = core.new.c_vmregions;
 527         c_vmm = (file_ptr) core.new.c_vmm;
 528       }
 529     else
 530       {
 531         c_datasize = core.old.c_datasize;
 532         c_data = (file_ptr) (ptr_to_uint) core.old.c_data;
 533         c_vmregions = core.old.c_vmregions;
 534         c_vmm = (file_ptr) (ptr_to_uint) core.old.c_vmm;
 535       }
 536
 537     /* .data section from executable.  */
 538     if (c_datasize)
 539       {
 540         if (!make_bfd_asection (abfd, ".data",
 541                                 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
 542                                 c_datasize,
 543                                 (bfd_vma) CDATA_ADDR (c_datasize),
 544                                 c_data))
 545           goto fail;
 546       }
 547
 548     /* .data sections from loaded objects.  */
 549     if (proc64)
 550       size = (int) ((LdInfo *) 0)->l64.ldinfo_filename;
 551     else
 552       size = (int) ((LdInfo *) 0)->l32.ldinfo_filename;
 553
 554     while (1)
 555       {
 556         if (bfd_seek (abfd, c_loader, SEEK_SET) != 0)
 557           goto fail;
 558         if (bfd_bread (&ldinfo, size, abfd) != size)
 559           goto fail;
 560
 561         if (proc64)
 562           {
 563             ldi_core = ldinfo.l64.ldinfo_core;
 564             ldi_datasize = ldinfo.l64.ldinfo_datasize;
 565             ldi_dataorg = (bfd_vma) ldinfo.l64.ldinfo_dataorg;
 566             ldi_next = ldinfo.l64.ldinfo_next;
 567           }
 568         else
 569           {
 570             ldi_core = ldinfo.l32.ldinfo_core;
 571             ldi_datasize = ldinfo.l32.ldinfo_datasize;
 572             ldi_dataorg = (bfd_vma) (long) ldinfo.l32.ldinfo_dataorg;
 573             ldi_next = ldinfo.l32.ldinfo_next;
 574           }
 575
 576         if (ldi_core)
 577           if (!make_bfd_asection (abfd, ".data",
 578                                   SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
 579                                   ldi_datasize, ldi_dataorg, ldi_core))
 580             goto fail;
 581
 582         if (ldi_next == 0)
 583           break;
 584         c_loader += ldi_next;
 585       }
 586
 587     /* .vmdata sections from anonymously mmapped regions.  */
 588     if (c_vmregions)
 589       {
 590         bfd_size_type i;
 591
 592         if (bfd_seek (abfd, c_vmm, SEEK_SET) != 0)
 593           goto fail;
 594
 595         for (i = 0; i < c_vmregions; i++)
 596           {
 597             VmInfo vminfo;
 598             bfd_size_type vminfo_size;
 599             file_ptr vminfo_offset;
 600             bfd_vma vminfo_addr;
 601
 602             size = CORE_NEW (core) ? sizeof (vminfo.new) : sizeof (vminfo.old);
 603             if (bfd_bread (&vminfo, size, abfd) != size)
 604               goto fail;
 605
 606             if (CORE_NEW (core))
 607               {
 608                 vminfo_addr = (bfd_vma) vminfo.new.vminfo_addr;
 609                 vminfo_size = vminfo.new.vminfo_size;
 610                 vminfo_offset = vminfo.new.vminfo_offset;
 611               }
 612             else
 613               {
 614                 vminfo_addr = (bfd_vma) (long) vminfo.old.vminfo_addr;
 615                 vminfo_size = vminfo.old.vminfo_size;
 616                 vminfo_offset = vminfo.old.vminfo_offset;
 617               }
 618
 619             if (vminfo_offset)
 620               if (!make_bfd_asection (abfd, ".vmdata",
 621                                       SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
 622                                       vminfo_size, vminfo_addr,
 623                                       vminfo_offset))
 624                 goto fail;
 625           }
 626       }
 627   }
 628 #endif
 629
 630   return abfd->xvec;            /* This is garbage for now.  */
 631
 632  fail:
 633   bfd_release (abfd, abfd->tdata.any);
 634   abfd->tdata.any = NULL;
 635   bfd_section_list_clear (abfd);
 636   return NULL;
 637 }
 638
 639 /* Return `TRUE' if given core is from the given executable.  */
 640
 641 bfd_boolean
 642 rs6000coff_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd)
 643 {
 644   CoreHdr core;
 645   bfd_size_type size;
 646   char *path, *s;
 647   size_t alloc;
 648   const char *str1, *str2;
 649   bfd_boolean ret;
 650   file_ptr c_loader;
 651
 652   if (!read_hdr (core_bfd, &core))
 653     return FALSE;
 654
 655   if (CORE_NEW (core))
 656     c_loader = CNEW_LOADER (core.new);
 657   else
 658     c_loader = (file_ptr) (ptr_to_uint) COLD_LOADER (core.old);
 659
 660   if (CORE_NEW (core) && CNEW_PROC64 (core.new))
 661     size = (int) ((LdInfo *) 0)->l64.ldinfo_filename;
 662   else
 663     size = (int) ((LdInfo *) 0)->l32.ldinfo_filename;
 664
 665   if (bfd_seek (core_bfd, c_loader + size, SEEK_SET) != 0)
 666     return FALSE;
 667
 668   alloc = 100;
 669   path = bfd_malloc ((bfd_size_type) alloc);
 670   if (path == NULL)
 671     return FALSE;
 672   s = path;
 673
 674   while (1)
 675     {
 676       if (bfd_bread (s, (bfd_size_type) 1, core_bfd) != 1)
 677         {
 678           free (path);
 679           return FALSE;
 680         }
 681       if (*s == '\0')
 682         break;
 683       ++s;
 684       if (s == path + alloc)
 685         {
 686           char *n;
 687
 688           alloc *= 2;
 689           n = bfd_realloc (path, (bfd_size_type) alloc);
 690           if (n == NULL)
 691             {
 692               free (path);
 693               return FALSE;
 694             }
 695           s = n + (path - s);
 696           path = n;
 697         }
 698     }
 699
 700   str1 = strrchr (path, '/');
 701   str2 = strrchr (exec_bfd->filename, '/');
 702
 703   /* step over character '/' */
 704   str1 = str1 != NULL ? str1 + 1 : path;
 705   str2 = str2 != NULL ? str2 + 1 : exec_bfd->filename;
 706
 707   if (strcmp (str1, str2) == 0)
 708     ret = TRUE;
 709   else
 710     ret = FALSE;
 711
 712   free (path);
 713
 714   return ret;
 715 }
 716
 717 char *
 718 rs6000coff_core_file_failing_command (bfd *abfd)
 719 {
 720   CoreHdr *core = core_hdr (abfd);
 721   char *com = CORE_NEW (*core) ?
 722     CNEW_COMM (core->new) : COLD_COMM (core->old);
 723
 724   if (*com)
 725     return com;
 726   else
 727     return 0;
 728 }
 729
 730 int
 731 rs6000coff_core_file_failing_signal (bfd *abfd)
 732 {
 733   CoreHdr *core = core_hdr (abfd);
 734   return CORE_NEW (*core) ? core->new.c_signo : core->old.c_signo;
 735 }
 736
 737 #endif /* AIX_CORE */