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, 2006, 2007
   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 "sysdep.h"
  48 #include "bfd.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_with_flags (abfd, name, flags);
 298   if (!asect)
 299     return NULL;
 300
 301   asect->size = size;
 302   asect->vma = vma;
 303   asect->filepos = filepos;
 304   asect->alignment_power = 8;
 305
 306   return asect;
 307 }
 308
 309 /* Decide if a given bfd represents a `core' file or not. There really is no
 310    magic number or anything like, in rs6000coff.  */
 311
 312 const bfd_target *
 313 rs6000coff_core_p (bfd *abfd)
 314 {
 315   CoreHdr core;
 316   struct stat statbuf;
 317   bfd_size_type size;
 318   char *tmpptr;
 319
 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;
 327
 328   if (!read_hdr (abfd, &core))
 329     {
 330       if (bfd_get_error () != bfd_error_system_call)
 331         bfd_set_error (bfd_error_wrong_format);
 332       return NULL;
 333     }
 334
 335   /* Copy fields from new or old core structure.  */
 336   if (CORE_NEW (core))
 337     {
 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);
 345     }
 346   else
 347     {
 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;
 355     }
 356
 357   if (proc64)
 358     {
 359       c_regsize = sizeof (CNEW_CONTEXT64 (core.new));
 360       c_regptr = &CNEW_CONTEXT64 (core.new);
 361     }
 362   else if (CORE_NEW (core))
 363     {
 364       c_regsize = sizeof (CNEW_MSTSAVE (core.new));
 365       c_regptr = &CNEW_MSTSAVE (core.new);
 366     }
 367   else
 368     {
 369       c_regsize = sizeof (COLD_MSTSAVE (core.old));
 370       c_regptr = &COLD_MSTSAVE (core.old);
 371     }
 372   c_regoff = (char *) c_regptr - (char *) &core;
 373
 374   if (bfd_stat (abfd, &statbuf) < 0)
 375     {
 376       bfd_set_error (bfd_error_system_call);
 377       return NULL;
 378     }
 379
 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).
 387
 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.  */
 394
 395   if (!(c_flag & UBLOCK_VALID)
 396       || !(c_flag & LE_VALID))
 397     {
 398       bfd_set_error (bfd_error_wrong_format);
 399       return NULL;
 400     }
 401
 402   if (!(c_flag & USTACK_VALID))
 403     {
 404       bfd_set_error (bfd_error_file_truncated);
 405       return NULL;
 406     }
 407
 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)))
 411     {
 412       /* If the size is wrong, it means we're misinterpreting something.  */
 413       if (c_stack + (file_ptr) c_size != statbuf.st_size)
 414         {
 415           bfd_set_error (bfd_error_wrong_format);
 416           return NULL;
 417         }
 418     }
 419
 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))
 424     {
 425       bfd_set_error (bfd_error_wrong_format);
 426       return NULL;
 427     }
 428
 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));
 433
 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;
 439
 440   /* Copy core file header.  */
 441   memcpy (tmpptr, &core, size);
 442   set_tdata (abfd, tmpptr);
 443
 444   /* Set architecture.  */
 445   if (CORE_NEW (core))
 446     {
 447       enum bfd_architecture arch;
 448       unsigned long mach;
 449
 450       switch (CNEW_IMPL (core.new))
 451         {
 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;
 462         }
 463       bfd_default_set_arch_mach (abfd, arch, mach);
 464     }
 465
 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;
 471
 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;
 477
 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;
 486
 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)
 495     {
 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;
 503     }
 504 #endif
 505
 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.  */
 510   {
 511     LdInfo ldinfo;
 512     bfd_size_type ldi_datasize;
 513     file_ptr ldi_core;
 514     uint ldi_next;
 515     bfd_vma ldi_dataorg;
 516
 517     /* Fields from new and old core structures.  */
 518     bfd_size_type c_datasize, c_vmregions;
 519     file_ptr c_data, c_vmm;
 520
 521     if (CORE_NEW (core))
 522       {
 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;
 527       }
 528     else
 529       {
 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;
 534       }
 535
 536     /* .data section from executable.  */
 537     if (c_datasize)
 538       {
 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;
 545       }
 546
 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;
 552
 553     while (1)
 554       {
 555         if (bfd_seek (abfd, c_loader, SEEK_SET) != 0)
 556           goto fail;
 557         if (bfd_bread (&ldinfo, size, abfd) != size)
 558           goto fail;
 559
 560         if (proc64)
 561           {
 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;
 566           }
 567         else
 568           {
 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;
 573           }
 574
 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;
 580
 581         if (ldi_next == 0)
 582           break;
 583         c_loader += ldi_next;
 584       }
 585
 586     /* .vmdata sections from anonymously mmapped regions.  */
 587     if (c_vmregions)
 588       {
 589         bfd_size_type i;
 590
 591         if (bfd_seek (abfd, c_vmm, SEEK_SET) != 0)
 592           goto fail;
 593
 594         for (i = 0; i < c_vmregions; i++)
 595           {
 596             VmInfo vminfo;
 597             bfd_size_type vminfo_size;
 598             file_ptr vminfo_offset;
 599             bfd_vma vminfo_addr;
 600
 601             size = CORE_NEW (core) ? sizeof (vminfo.new) : sizeof (vminfo.old);
 602             if (bfd_bread (&vminfo, size, abfd) != size)
 603               goto fail;
 604
 605             if (CORE_NEW (core))
 606               {
 607                 vminfo_addr = (bfd_vma) vminfo.new.vminfo_addr;
 608                 vminfo_size = vminfo.new.vminfo_size;
 609                 vminfo_offset = vminfo.new.vminfo_offset;
 610               }
 611             else
 612               {
 613                 vminfo_addr = (bfd_vma) (long) vminfo.old.vminfo_addr;
 614                 vminfo_size = vminfo.old.vminfo_size;
 615                 vminfo_offset = vminfo.old.vminfo_offset;
 616               }
 617
 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;
 624           }
 625       }
 626   }
 627 #endif
 628
 629   return abfd->xvec;            /* This is garbage for now.  */
 630
 631  fail:
 632   bfd_release (abfd, abfd->tdata.any);
 633   abfd->tdata.any = NULL;
 634   bfd_section_list_clear (abfd);
 635   return NULL;
 636 }
 637
 638 /* Return `TRUE' if given core is from the given executable.  */
 639
 640 bfd_boolean
 641 rs6000coff_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd)
 642 {
 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;
 650
 651   if (!read_hdr (core_bfd, &core))
 652     return FALSE;
 653
 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);
 658
 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;
 663
 664   if (bfd_seek (core_bfd, c_loader + size, SEEK_SET) != 0)
 665     return FALSE;
 666
 667   alloc = 100;
 668   path = bfd_malloc ((bfd_size_type) alloc);
 669   if (path == NULL)
 670     return FALSE;
 671   s = path;
 672
 673   while (1)
 674     {
 675       if (bfd_bread (s, (bfd_size_type) 1, core_bfd) != 1)
 676         {
 677           free (path);
 678           return FALSE;
 679         }
 680       if (*s == '\0')
 681         break;
 682       ++s;
 683       if (s == path + alloc)
 684         {
 685           char *n;
 686
 687           alloc *= 2;
 688           n = bfd_realloc (path, (bfd_size_type) alloc);
 689           if (n == NULL)
 690             {
 691               free (path);
 692               return FALSE;
 693             }
 694           s = n + (path - s);
 695           path = n;
 696         }
 697     }
 698
 699   str1 = strrchr (path, '/');
 700   str2 = strrchr (exec_bfd->filename, '/');
 701
 702   /* step over character '/' */
 703   str1 = str1 != NULL ? str1 + 1 : path;
 704   str2 = str2 != NULL ? str2 + 1 : exec_bfd->filename;
 705
 706   if (strcmp (str1, str2) == 0)
 707     ret = TRUE;
 708   else
 709     ret = FALSE;
 710
 711   free (path);
 712
 713   return ret;
 714 }
 715
 716 char *
 717 rs6000coff_core_file_failing_command (bfd *abfd)
 718 {
 719   CoreHdr *core = core_hdr (abfd);
 720   char *com = CORE_NEW (*core) ?
 721     CNEW_COMM (core->new) : COLD_COMM (core->old);
 722
 723   if (*com)
 724     return com;
 725   else
 726     return 0;
 727 }
 728
 729 int
 730 rs6000coff_core_file_failing_signal (bfd *abfd)
 731 {
 732   CoreHdr *core = core_hdr (abfd);
 733   return CORE_NEW (*core) ? core->new.c_signo : core->old.c_signo;
 734 }
 735
 736 #endif /* AIX_CORE */