bfd/rs6000-core.c

   1 /* IBM RS/6000 "XCOFF" back-end for BFD.
   2    Copyright (C) 1990-2015 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.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   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.
  13
  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.
  18
  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.  */
  23
  24
  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.
  28
  29    This is in a separate file from coff-rs6000.c, because it includes
  30    system include files that conflict with coff/rs6000.h.  */
  31
  32 /* Internalcoff.h and coffcode.h modify themselves based on this flag.  */
  33 #define RS6000COFF_C 1
  34
  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)
  39 #define _LONG_LONG
  40 #endif
  41
  42 #include "sysdep.h"
  43 #include "bfd.h"
  44 #include "libbfd.h"
  45
  46 #ifdef AIX_CORE
  47
  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.  */
  51 #ifdef AOUTHDR
  52 #undef AOUTHDR
  53 #endif
  54 #define AOUTHDR second_AOUTHDR
  55
  56 #undef  SCNHDR
  57
  58 /* ------------------------------------------------------------------------ */
  59 /*      Support for core file stuff..                                       */
  60 /* ------------------------------------------------------------------------ */
  61
  62 #include <sys/user.h>
  63 #define __LDINFO_PTRACE32__     /* for __ld_info32 */
  64 #define __LDINFO_PTRACE64__     /* for __ld_info64 */
  65 #include <sys/ldr.h>
  66 #include <sys/core.h>
  67 #include <sys/systemcfg.h>
  68
  69 /* Borrowed from <sys/inttypes.h> on recent AIX versions.  */
  70 typedef unsigned long ptr_to_uint;
  71
  72 #define core_hdr(bfd)           ((CoreHdr *) bfd->tdata.any)
  73
  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.
  77
  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.  */
  82
  83 #if defined(CORE_VERSION_1) && !CORE_VERSION_1
  84 # undef CORE_VERSION_1
  85 #endif
  86
  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
  90    values.  */
  91
  92 /* Union of 32-bit and 64-bit versions of ld_info.  */
  93
  94 typedef union {
  95 #ifdef __ld_info32
  96   struct __ld_info32 l32;
  97   struct __ld_info64 l64;
  98 #else
  99   struct ld_info l32;
 100   struct ld_info l64;
 101 #endif
 102 } LdInfo;
 103
 104 /* Union of old and new core dump structures.  */
 105
 106 typedef union {
 107 #ifdef AIX_CORE_DUMPX_CORE
 108   struct core_dumpx new_dump;   /* new AIX 4.3+ core dump */
 109 #else
 110   struct core_dump new_dump;            /* for simpler coding */
 111 #endif
 112   struct core_dump old;         /* old AIX 4.2- core dump, still used on
 113                                    4.3+ with appropriate SMIT config */
 114 } CoreHdr;
 115
 116 /* Union of old and new vm_info structures.  */
 117
 118 #ifdef CORE_VERSION_1
 119 typedef union {
 120 #ifdef AIX_CORE_DUMPX_CORE
 121   struct vm_infox new_dump;
 122 #else
 123   struct vm_info new_dump;
 124 #endif
 125   struct vm_info old;
 126 } VmInfo;
 127 #endif
 128
 129 /* Return whether CoreHdr C is in new or old format.  */
 130
 131 #ifdef AIX_CORE_DUMPX_CORE
 132 # define CORE_NEW(c)    (!(c).old.c_entries)
 133 #else
 134 # define CORE_NEW(c)    0
 135 #endif
 136
 137 /* Return whether CoreHdr C usese core_dumpxx structure.
 138
 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.  */
 142
 143 #ifdef AIX_5_CORE
 144 # define CORE_DUMPXX_VERSION    267312562
 145 # define CNEW_IS_CORE_DUMPXX(c) ((c).new_dump.c_version == CORE_DUMPXX_VERSION)
 146 #else
 147 # define CNEW_IS_CORE_DUMPXX(c) 0
 148 #endif
 149
 150 /* Return the c_stackorg field from struct core_dumpx C.  */
 151
 152 #ifdef AIX_CORE_DUMPX_CORE
 153 # define CNEW_STACKORG(c)       (c).c_stackorg
 154 #else
 155 # define CNEW_STACKORG(c)       0
 156 #endif
 157
 158 /* Return the offset to the loader region from struct core_dump C.  */
 159
 160 #ifdef AIX_CORE_DUMPX_CORE
 161 # define CNEW_LOADER(c) (c).c_loader
 162 #else
 163 # define CNEW_LOADER(c) 0
 164 #endif
 165
 166 /* Return the offset to the loader region from struct core_dump C.  */
 167
 168 #define COLD_LOADER(c)  (c).c_tab
 169
 170 /* Return the c_lsize field from struct core_dumpx C.  */
 171
 172 #ifdef AIX_CORE_DUMPX_CORE
 173 # define CNEW_LSIZE(c)  (c).c_lsize
 174 #else
 175 # define CNEW_LSIZE(c)  0
 176 #endif
 177
 178 /* Return the c_dataorg field from struct core_dumpx C.  */
 179
 180 #ifdef AIX_CORE_DUMPX_CORE
 181 # define CNEW_DATAORG(c)        (c).c_dataorg
 182 #else
 183 # define CNEW_DATAORG(c)        0
 184 #endif
 185
 186 /* Return the c_datasize field from struct core_dumpx C.  */
 187
 188 #ifdef AIX_CORE_DUMPX_CORE
 189 # define CNEW_DATASIZE(c)       (c).c_datasize
 190 #else
 191 # define CNEW_DATASIZE(c)       0
 192 #endif
 193
 194 /* Return the c_impl field from struct core_dumpx C.  */
 195
 196 #if defined (HAVE_ST_C_IMPL) || defined (AIX_5_CORE)
 197 # define CNEW_IMPL(c)   (c).c_impl
 198 #else
 199 # define CNEW_IMPL(c)   0
 200 #endif
 201
 202 /* Return the command string from struct core_dumpx C.  */
 203
 204 #ifdef AIX_CORE_DUMPX_CORE
 205 # define CNEW_COMM(c)   (c).c_u.U_proc.pi_comm
 206 #else
 207 # define CNEW_COMM(c)   0
 208 #endif
 209
 210 /* Return the command string from struct core_dump C.  */
 211
 212 #ifdef CORE_VERSION_1
 213 # define COLD_COMM(c)   (c).c_u.U_comm
 214 #else
 215 # define COLD_COMM(c)   (c).c_u.u_comm
 216 #endif
 217
 218 /* Return the struct __context64 pointer from struct core_dumpx C.  */
 219
 220 #ifdef AIX_CORE_DUMPX_CORE
 221 # define CNEW_CONTEXT64(c)      (c).c_flt.hctx.r64
 222 #else
 223 # define CNEW_CONTEXT64(c)      c
 224 #endif
 225
 226 /* Return the struct mstsave pointer from struct core_dumpx C.  */
 227
 228 #ifdef AIX_CORE_DUMPX_CORE
 229 # define CNEW_MSTSAVE(c)        (c).c_flt.hctx.r32
 230 #else
 231 # define CNEW_MSTSAVE(c)        c
 232 #endif
 233
 234 /* Return the struct mstsave pointer from struct core_dump C.  */
 235
 236 #ifdef CORE_VERSION_1
 237 # define COLD_MSTSAVE(c)        (c).c_mst
 238 #else
 239 # define COLD_MSTSAVE(c)        (c).c_u.u_save
 240 #endif
 241
 242 /* Return whether struct core_dumpx is from a 64-bit process.  */
 243
 244 #ifdef AIX_CORE_DUMPX_CORE
 245 # define CNEW_PROC64(c)         IS_PROC64(&(c).c_u.U_proc)
 246 #else
 247 # define CNEW_PROC64(c)         0
 248 #endif
 249
 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.  */
 252
 253 #ifdef CORE_VERSION_1
 254 # define COLD_STACKEND  0x2ff23000
 255 #else
 256 # define COLD_STACKEND  0x2ff80000
 257 #endif
 258
 259 /* Size of the leading portion that old and new core dump structures have in
 260    common.  */
 261 #define CORE_COMMONSZ   ((int) &((struct core_dump *) 0)->c_entries \
 262                          + sizeof (((struct core_dump *) 0)->c_entries))
 263
 264 /* Define prototypes for certain functions, to avoid a compiler warning
 265    saying that they are missing.  */
 266
 267 const bfd_target * rs6000coff_core_p (bfd *abfd);
 268 bfd_boolean rs6000coff_core_file_matches_executable_p (bfd *core_bfd,
 269                                                        bfd *exec_bfd);
 270 char * rs6000coff_core_file_failing_command (bfd *abfd);
 271 int rs6000coff_core_file_failing_signal (bfd *abfd);
 272
 273 /* Try to read into CORE the header from the core file associated with ABFD.
 274    Return success.  */
 275
 276 static bfd_boolean
 277 read_hdr (bfd *abfd, CoreHdr *core)
 278 {
 279   bfd_size_type size;
 280
 281   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 282     return FALSE;
 283
 284   /* Read the leading portion that old and new core dump structures have in
 285      common.  */
 286   size = CORE_COMMONSZ;
 287   if (bfd_bread (core, size, abfd) != size)
 288     return FALSE;
 289
 290   /* Read the trailing portion of the structure.  */
 291   if (CORE_NEW (*core))
 292     size = sizeof (core->new_dump);
 293   else
 294     size = sizeof (core->old);
 295   size -= CORE_COMMONSZ;
 296   return bfd_bread ((char *) core + CORE_COMMONSZ, size, abfd) == size;
 297 }
 298
 299 static asection *
 300 make_bfd_asection (bfd *abfd, const char *name, flagword flags,
 301                    bfd_size_type size, bfd_vma vma, file_ptr filepos)
 302 {
 303   asection *asect;
 304
 305   asect = bfd_make_section_anyway_with_flags (abfd, name, flags);
 306   if (!asect)
 307     return NULL;
 308
 309   asect->size = size;
 310   asect->vma = vma;
 311   asect->filepos = filepos;
 312   asect->alignment_power = 8;
 313
 314   return asect;
 315 }
 316
 317 /* Decide if a given bfd represents a `core' file or not. There really is no
 318    magic number or anything like, in rs6000coff.  */
 319
 320 const bfd_target *
 321 rs6000coff_core_p (bfd *abfd)
 322 {
 323   CoreHdr core;
 324   struct stat statbuf;
 325   bfd_size_type size;
 326   char *tmpptr;
 327
 328   /* Values from new and old core structures.  */
 329   int c_flag;
 330   file_ptr c_stack, c_regoff, c_loader;
 331   bfd_size_type c_size, c_regsize, c_lsize;
 332   bfd_vma c_stackend;
 333   void *c_regptr;
 334   int proc64;
 335
 336   if (!read_hdr (abfd, &core))
 337     {
 338       if (bfd_get_error () != bfd_error_system_call)
 339         bfd_set_error (bfd_error_wrong_format);
 340       return NULL;
 341     }
 342
 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))
 345     {
 346       bfd_set_error (bfd_error_wrong_format);
 347       return NULL;
 348     }
 349
 350   /* Copy fields from new or old core structure.  */
 351   if (CORE_NEW (core))
 352     {
 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);
 360     }
 361   else
 362     {
 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;
 367       c_lsize = 0x7ffffff;
 368       c_loader = (file_ptr) (ptr_to_uint) COLD_LOADER (core.old);
 369       proc64 = 0;
 370     }
 371
 372   if (proc64)
 373     {
 374       c_regsize = sizeof (CNEW_CONTEXT64 (core.new_dump));
 375       c_regptr = &CNEW_CONTEXT64 (core.new_dump);
 376     }
 377   else if (CORE_NEW (core))
 378     {
 379       c_regsize = sizeof (CNEW_MSTSAVE (core.new_dump));
 380       c_regptr = &CNEW_MSTSAVE (core.new_dump);
 381     }
 382   else
 383     {
 384       c_regsize = sizeof (COLD_MSTSAVE (core.old));
 385       c_regptr = &COLD_MSTSAVE (core.old);
 386     }
 387   c_regoff = (char *) c_regptr - (char *) &core;
 388
 389   if (bfd_stat (abfd, &statbuf) < 0)
 390     {
 391       bfd_set_error (bfd_error_system_call);
 392       return NULL;
 393     }
 394
 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).
 402
 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
 408      limited anyway.  */
 409
 410   if (!(c_flag & UBLOCK_VALID)
 411       || !(c_flag & LE_VALID))
 412     {
 413       bfd_set_error (bfd_error_wrong_format);
 414       return NULL;
 415     }
 416
 417   if (!(c_flag & USTACK_VALID))
 418     {
 419       bfd_set_error (bfd_error_file_truncated);
 420       return NULL;
 421     }
 422
 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)))
 426     {
 427       /* If the size is wrong, it means we're misinterpreting something.  */
 428       if (c_stack + (file_ptr) c_size != statbuf.st_size)
 429         {
 430           bfd_set_error (bfd_error_wrong_format);
 431           return NULL;
 432         }
 433     }
 434
 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))
 439     {
 440       bfd_set_error (bfd_error_wrong_format);
 441       return NULL;
 442     }
 443
 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));
 448
 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);
 452   if (!tmpptr)
 453     return NULL;
 454
 455   /* Copy core file header.  */
 456   memcpy (tmpptr, &core, size);
 457   set_tdata (abfd, tmpptr);
 458
 459   /* Set architecture.  */
 460   if (CORE_NEW (core))
 461     {
 462       enum bfd_architecture arch;
 463       unsigned long mach;
 464
 465       switch (CNEW_IMPL (core.new_dump))
 466         {
 467         case POWER_RS1:
 468         case POWER_RSC:
 469         case POWER_RS2:
 470           arch = bfd_arch_rs6000;
 471           mach = bfd_mach_rs6k;
 472           break;
 473         default:
 474           arch = bfd_arch_powerpc;
 475           mach = bfd_mach_ppc;
 476           break;
 477         }
 478       bfd_default_set_arch_mach (abfd, arch, mach);
 479     }
 480
 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))
 485     goto fail;
 486
 487   /* .reg section for all registers.  */
 488   if (!make_bfd_asection (abfd, ".reg",
 489                           SEC_HAS_CONTENTS,
 490                           c_regsize, (bfd_vma) 0, c_regoff))
 491     goto fail;
 492
 493   /* .ldinfo section.
 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",
 498                           SEC_HAS_CONTENTS,
 499                           c_lsize, (bfd_vma) 0, c_loader))
 500     goto fail;
 501
 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)
 510     {
 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,
 514                               (bfd_vma)
 515                                 CDATA_ADDR (core.old.c_u.u_dsize),
 516                               c_stack + c_size))
 517         goto fail;
 518     }
 519 #endif
 520
 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
 524      regions.  */
 525   {
 526     LdInfo ldinfo;
 527     bfd_size_type ldi_datasize;
 528     file_ptr ldi_core;
 529     uint ldi_next;
 530     bfd_vma ldi_dataorg;
 531
 532     /* Fields from new and old core structures.  */
 533     bfd_size_type c_datasize, c_vmregions;
 534     file_ptr c_data, c_vmm;
 535
 536     if (CORE_NEW (core))
 537       {
 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;
 542       }
 543     else
 544       {
 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;
 549       }
 550
 551     /* .data section from executable.  */
 552     if (c_datasize)
 553       {
 554         if (!make_bfd_asection (abfd, ".data",
 555                                 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
 556                                 c_datasize,
 557                                 (bfd_vma) CDATA_ADDR (c_datasize),
 558                                 c_data))
 559           goto fail;
 560       }
 561
 562     /* .data sections from loaded objects.  */
 563     if (proc64)
 564       size = (int) ((LdInfo *) 0)->l64.ldinfo_filename;
 565     else
 566       size = (int) ((LdInfo *) 0)->l32.ldinfo_filename;
 567
 568     while (1)
 569       {
 570         if (bfd_seek (abfd, c_loader, SEEK_SET) != 0)
 571           goto fail;
 572         if (bfd_bread (&ldinfo, size, abfd) != size)
 573           goto fail;
 574
 575         if (proc64)
 576           {
 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;
 581           }
 582         else
 583           {
 584             ldi_core = ldinfo.l32.ldinfo_core;
 585             ldi_datasize = ldinfo.l32.ldinfo_datasize;
 586             ldi_dataorg = (bfd_vma) (ptr_to_uint) ldinfo.l32.ldinfo_dataorg;
 587             ldi_next = ldinfo.l32.ldinfo_next;
 588           }
 589
 590         if (ldi_core)
 591           if (!make_bfd_asection (abfd, ".data",
 592                                   SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
 593                                   ldi_datasize, ldi_dataorg, ldi_core))
 594             goto fail;
 595
 596         if (ldi_next == 0)
 597           break;
 598         c_loader += ldi_next;
 599       }
 600
 601     /* .vmdata sections from anonymously mmapped regions.  */
 602     if (c_vmregions)
 603       {
 604         bfd_size_type i;
 605
 606         if (bfd_seek (abfd, c_vmm, SEEK_SET) != 0)
 607           goto fail;
 608
 609         for (i = 0; i < c_vmregions; i++)
 610           {
 611             VmInfo vminfo;
 612             bfd_size_type vminfo_size;
 613             file_ptr vminfo_offset;
 614             bfd_vma vminfo_addr;
 615
 616             size = CORE_NEW (core) ? sizeof (vminfo.new_dump) : sizeof (vminfo.old);
 617             if (bfd_bread (&vminfo, size, abfd) != size)
 618               goto fail;
 619
 620             if (CORE_NEW (core))
 621               {
 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;
 625               }
 626             else
 627               {
 628                 vminfo_addr = (bfd_vma) (ptr_to_uint) vminfo.old.vminfo_addr;
 629                 vminfo_size = vminfo.old.vminfo_size;
 630                 vminfo_offset = vminfo.old.vminfo_offset;
 631               }
 632
 633             if (vminfo_offset)
 634               if (!make_bfd_asection (abfd, ".vmdata",
 635                                       SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
 636                                       vminfo_size, vminfo_addr,
 637                                       vminfo_offset))
 638                 goto fail;
 639           }
 640       }
 641   }
 642 #endif
 643
 644   return abfd->xvec;            /* This is garbage for now.  */
 645
 646  fail:
 647   bfd_release (abfd, abfd->tdata.any);
 648   abfd->tdata.any = NULL;
 649   bfd_section_list_clear (abfd);
 650   return NULL;
 651 }
 652
 653 /* Return `TRUE' if given core is from the given executable.  */
 654
 655 bfd_boolean
 656 rs6000coff_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd)
 657 {
 658   CoreHdr core;
 659   bfd_size_type size;
 660   char *path, *s;
 661   size_t alloc;
 662   const char *str1, *str2;
 663   bfd_boolean ret;
 664   file_ptr c_loader;
 665
 666   if (!read_hdr (core_bfd, &core))
 667     return FALSE;
 668
 669   if (CORE_NEW (core))
 670     c_loader = CNEW_LOADER (core.new_dump);
 671   else
 672     c_loader = (file_ptr) (ptr_to_uint) COLD_LOADER (core.old);
 673
 674   if (CORE_NEW (core) && CNEW_PROC64 (core.new_dump))
 675     size = (int) ((LdInfo *) 0)->l64.ldinfo_filename;
 676   else
 677     size = (int) ((LdInfo *) 0)->l32.ldinfo_filename;
 678
 679   if (bfd_seek (core_bfd, c_loader + size, SEEK_SET) != 0)
 680     return FALSE;
 681
 682   alloc = 100;
 683   path = bfd_malloc ((bfd_size_type) alloc);
 684   if (path == NULL)
 685     return FALSE;
 686   s = path;
 687
 688   while (1)
 689     {
 690       if (bfd_bread (s, (bfd_size_type) 1, core_bfd) != 1)
 691         {
 692           free (path);
 693           return FALSE;
 694         }
 695       if (*s == '\0')
 696         break;
 697       ++s;
 698       if (s == path + alloc)
 699         {
 700           char *n;
 701
 702           alloc *= 2;
 703           n = bfd_realloc (path, (bfd_size_type) alloc);
 704           if (n == NULL)
 705             {
 706               free (path);
 707               return FALSE;
 708             }
 709           s = n + (path - s);
 710           path = n;
 711         }
 712     }
 713
 714   str1 = strrchr (path, '/');
 715   str2 = strrchr (exec_bfd->filename, '/');
 716
 717   /* step over character '/' */
 718   str1 = str1 != NULL ? str1 + 1 : path;
 719   str2 = str2 != NULL ? str2 + 1 : exec_bfd->filename;
 720
 721   if (strcmp (str1, str2) == 0)
 722     ret = TRUE;
 723   else
 724     ret = FALSE;
 725
 726   free (path);
 727
 728   return ret;
 729 }
 730
 731 char *
 732 rs6000coff_core_file_failing_command (bfd *abfd)
 733 {
 734   CoreHdr *core = core_hdr (abfd);
 735   char *com = CORE_NEW (*core) ?
 736     CNEW_COMM (core->new_dump) : COLD_COMM (core->old);
 737
 738   if (*com)
 739     return com;
 740   else
 741     return 0;
 742 }
 743
 744 int
 745 rs6000coff_core_file_failing_signal (bfd *abfd)
 746 {
 747   CoreHdr *core = core_hdr (abfd);
 748   return CORE_NEW (*core) ? core->new_dump.c_signo : core->old.c_signo;
 749 }
 750
 751 #endif /* AIX_CORE */