bfd/rs6000-core.c

   1 /* IBM RS/6000 "XCOFF" back-end for BFD.
   2    Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 1998
   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
   7    character set it is.
   8    Written by Metin G. Ozisik, Mimi Ph\373\364ng-Th\345o V\365,
   9      and John Gilmore.
  10    Archive support from Damon A. Permezel.
  11    Contributed by IBM Corporation and Cygnus Support.
  12
  13 This file is part of BFD, the Binary File Descriptor library.
  14
  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.
  19
  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.
  24
  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.  */
  28
  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.
  32
  33    FIXMEmgo comments are left from Metin Ozisik's original port.
  34
  35    This is in a separate file from coff-rs6000.c, because it includes
  36    system include files that conflict with coff/rs6000.h.
  37   */
  38
  39 /* Internalcoff.h and coffcode.h modify themselves based on this flag.  */
  40 #define RS6000COFF_C 1
  41
  42 /* The AIX 4.1 kernel is obviously compiled with -D_LONG_LONG, so
  43    we have to define _LONG_LONG for older versions of gcc to get the
  44    proper alignments in the user structure.  */
  45 #if defined(_AIX41) && !defined(_LONG_LONG)
  46 #define _LONG_LONG
  47 #endif
  48
  49 #include "bfd.h"
  50 #include "sysdep.h"
  51 #include "libbfd.h"
  52
  53 #ifdef AIX_CORE
  54
  55 /* AOUTHDR is defined by the above.  We need another defn of it, from the
  56    system include files.  Punt the old one and get us a new name for the
  57    typedef in the system include files.  */
  58 #ifdef AOUTHDR
  59 #undef AOUTHDR
  60 #endif
  61 #define AOUTHDR second_AOUTHDR
  62
  63 #undef  SCNHDR
  64
  65
  66 /* ------------------------------------------------------------------------ */
  67 /*      Support for core file stuff..                                       */
  68 /* ------------------------------------------------------------------------ */
  69
  70 #include <sys/user.h>
  71 #include <sys/ldr.h>
  72 #include <sys/core.h>
  73
  74
  75 /* Number of special purpose registers supported by gdb.  This value
  76    should match `tm.h' in gdb directory.  Clean this mess up and use
  77    the macros in sys/reg.h.  FIXMEmgo. */
  78
  79 #define NUM_OF_SPEC_REGS  7
  80
  81 #define core_hdr(bfd)           (((Rs6kCorData*)(bfd->tdata.any))->hdr)
  82
  83 /* AIX 4.1 Changed the names and locations of a few items in the core file,
  84    this seems to be the quickest easiet way to deal with it.
  85
  86    Note however that encoding magic addresses (STACK_END_ADDR) is going
  87    to be _very_ fragile.  But I don't see any easy way to get that info
  88    right now.  */
  89 #ifdef CORE_VERSION_1
  90 #define CORE_DATA_SIZE_FIELD c_u.U_dsize
  91 #define CORE_COMM_FIELD c_u.U_comm
  92 #define SAVE_FIELD c_mst
  93 #define STACK_END_ADDR 0x2ff23000
  94 #else
  95 #define CORE_DATA_SIZE_FIELD c_u.u_dsize
  96 #define CORE_COMM_FIELD c_u.u_comm
  97 #define SAVE_FIELD c_u.u_save
  98 #define STACK_END_ADDR 0x2ff80000
  99 #endif
 100
 101 /* These are stored in the bfd's tdata */
 102 typedef struct {
 103   struct core_dump hdr;         /* core file header */
 104 } Rs6kCorData;
 105
 106 static asection *make_bfd_asection PARAMS ((bfd *, CONST char *, flagword,
 107                                             bfd_size_type, bfd_vma, file_ptr));
 108
 109 static asection *
 110 make_bfd_asection (abfd, name, flags, _raw_size, vma, filepos)
 111      bfd *abfd;
 112      CONST char *name;
 113      flagword flags;
 114      bfd_size_type _raw_size;
 115      bfd_vma vma;
 116      file_ptr filepos;
 117 {
 118   asection *asect;
 119
 120   asect = bfd_make_section_anyway (abfd, name);
 121   if (!asect)
 122     return NULL;
 123
 124   asect->flags = flags;
 125   asect->_raw_size = _raw_size;
 126   asect->vma = vma;
 127   asect->filepos = filepos;
 128   asect->alignment_power = 8;
 129
 130   return asect;
 131 }
 132
 133 /* Decide if a given bfd represents a `core' file or not. There really is no
 134    magic number or anything like, in rs6000coff. */
 135
 136 const bfd_target *
 137 rs6000coff_core_p (abfd)
 138      bfd *abfd;
 139 {
 140   struct core_dump coredata;
 141   struct stat statbuf;
 142   bfd_size_type nread;
 143   char *tmpptr;
 144
 145   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 146     return NULL;
 147
 148   nread = bfd_read (&coredata, 1, sizeof (struct core_dump), abfd);
 149   if (nread != sizeof (struct core_dump))
 150     {
 151       if (bfd_get_error () != bfd_error_system_call)
 152         bfd_set_error (bfd_error_wrong_format);
 153       return NULL;
 154     }
 155
 156   if (bfd_stat (abfd, &statbuf) < 0)
 157     {
 158       bfd_set_error (bfd_error_system_call);
 159       return NULL;
 160     }
 161
 162   /* If the core file ulimit is too small, the system will first
 163      omit the data segment, then omit the stack, then decline to
 164      dump core altogether (as far as I know UBLOCK_VALID and LE_VALID
 165      are always set) (this is based on experimentation on AIX 3.2).
 166      Now, the thing is that GDB users will be surprised
 167      if segments just silently don't appear (well, maybe they would
 168      think to check "info files", I don't know).
 169
 170      For the data segment, we have no choice but to keep going if it's
 171      not there, since the default behavior is not to dump it (regardless
 172      of the ulimit, it's based on SA_FULLDUMP).  But for the stack segment,
 173      if it's not there, we refuse to have anything to do with this core
 174      file.  The usefulness of a core dump without a stack segment is pretty
 175      limited anyway.  */
 176
 177   if (!(coredata.c_flag & UBLOCK_VALID)
 178       || !(coredata.c_flag & LE_VALID))
 179     {
 180       bfd_set_error (bfd_error_wrong_format);
 181       return NULL;
 182     }
 183
 184   if (!(coredata.c_flag & USTACK_VALID))
 185     {
 186       bfd_set_error (bfd_error_file_truncated);
 187       return NULL;
 188     }
 189
 190   /* Don't check the core file size for a full core, AIX 4.1 includes
 191      additional shared library sections in a full core.  */
 192   if (!(coredata.c_flag & (FULL_CORE | CORE_TRUNC))
 193       && ((bfd_vma)coredata.c_stack + coredata.c_size) != statbuf.st_size)
 194     {
 195       /* If the size is wrong, it means we're misinterpreting something.  */
 196       bfd_set_error (bfd_error_wrong_format);
 197       return NULL;
 198     }
 199
 200   /* Sanity check on the c_tab field.  */
 201   if ((u_long) coredata.c_tab < sizeof coredata ||
 202       (u_long) coredata.c_tab >= statbuf.st_size ||
 203       (long) coredata.c_tab >= (long)coredata.c_stack)
 204     {
 205       bfd_set_error (bfd_error_wrong_format);
 206       return NULL;
 207     }
 208
 209   /* Issue warning if the core file was truncated during writing.  */
 210   if (coredata.c_flag & CORE_TRUNC)
 211     (*_bfd_error_handler) (_("%s: warning core file truncated"),
 212                            bfd_get_filename (abfd));
 213
 214   /* Allocate core file header.  */
 215   tmpptr = (char*) bfd_zalloc (abfd, sizeof (Rs6kCorData));
 216   if (!tmpptr)
 217     return NULL;
 218
 219   set_tdata (abfd, tmpptr);
 220
 221   /* Copy core file header.  */
 222   core_hdr (abfd) = coredata;
 223
 224   /* .stack section. */
 225   if (!make_bfd_asection (abfd, ".stack",
 226                           SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
 227                           (bfd_size_type) coredata.c_size,
 228                           (bfd_vma) (STACK_END_ADDR - coredata.c_size),
 229                           (file_ptr) coredata.c_stack))
 230     return NULL;
 231
 232   /* .reg section for GPRs and special registers. */
 233   if (!make_bfd_asection (abfd, ".reg",
 234                           SEC_HAS_CONTENTS,
 235                           (bfd_size_type) ((32 + NUM_OF_SPEC_REGS) * 4),
 236                           (bfd_vma) 0,
 237                           (file_ptr) ((char *) &coredata.SAVE_FIELD
 238                                       - (char *) &coredata)))
 239     return NULL;
 240
 241   /* .reg2 section for FPRs (floating point registers). */
 242   if (!make_bfd_asection (abfd, ".reg2",
 243                           SEC_HAS_CONTENTS,
 244                           (bfd_size_type) 8 * 32,       /* 32 FPRs. */
 245                           (bfd_vma) 0,
 246                           (file_ptr) ((char *) &coredata.SAVE_FIELD.fpr[0]
 247                                       - (char *) &coredata)))
 248     return NULL;
 249
 250   /* .ldinfo section.
 251      To actually find out how long this section is in this particular
 252      core dump would require going down the whole list of struct ld_info's.
 253      See if we can just fake it.  */
 254   if (!make_bfd_asection (abfd, ".ldinfo",
 255                           SEC_HAS_CONTENTS,
 256                           (bfd_size_type) 0x7fffffff,
 257                           (bfd_vma) 0,
 258                           (file_ptr) coredata.c_tab))
 259     return NULL;
 260
 261 #ifndef CORE_VERSION_1
 262   /* .data section if present.
 263      AIX 3 dumps the complete data section and sets FULL_CORE if the
 264      ulimit is large enough, otherwise the data section is omitted.
 265      AIX 4 sets FULL_CORE even if the core file is truncated, we have
 266      to examine coredata.c_datasize below to find out the actual size of
 267      the .data section.  */
 268   if (coredata.c_flag & FULL_CORE)
 269     {
 270       if (!make_bfd_asection (abfd, ".data",
 271                               SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
 272                               (bfd_size_type) coredata.CORE_DATA_SIZE_FIELD,
 273                               (bfd_vma)
 274                                 CDATA_ADDR (coredata.CORE_DATA_SIZE_FIELD),
 275                               (file_ptr) coredata.c_stack + coredata.c_size))
 276         return NULL;
 277     }
 278 #endif
 279
 280 #ifdef CORE_VERSION_1
 281   /* AIX 4 adds data sections from loaded objects to the core file,
 282      which can be found by examining ldinfo, and anonymously mmapped
 283      regions.  */
 284   {
 285     struct ld_info ldinfo;
 286     bfd_size_type ldinfo_size;
 287     file_ptr ldinfo_offset = (file_ptr) coredata.c_tab;
 288
 289     /* .data section from executable.  */
 290     if (coredata.c_datasize)
 291       {
 292         if (!make_bfd_asection (abfd, ".data",
 293                                 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
 294                                 (bfd_size_type) coredata.c_datasize,
 295                                 (bfd_vma)
 296                                   CDATA_ADDR (coredata.CORE_DATA_SIZE_FIELD),
 297                                 (file_ptr) coredata.c_data))
 298           return NULL;
 299       }
 300
 301     /* .data sections from loaded objects.  */
 302     ldinfo_size = (char *) &ldinfo.ldinfo_filename[0]
 303                   - (char *) &ldinfo.ldinfo_next;
 304     while (1)
 305       {
 306         if (bfd_seek (abfd, ldinfo_offset, SEEK_SET) != 0)
 307           return NULL;
 308         if (bfd_read (&ldinfo, ldinfo_size, 1, abfd) != ldinfo_size)
 309           return NULL;
 310         if (ldinfo.ldinfo_core)
 311           {
 312             if (!make_bfd_asection (abfd, ".data",
 313                                     SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
 314                                     (bfd_size_type) ldinfo.ldinfo_datasize,
 315                                     (bfd_vma) ldinfo.ldinfo_dataorg,
 316                                     (file_ptr) ldinfo.ldinfo_core))
 317               return NULL;
 318           }
 319         if (ldinfo.ldinfo_next == 0)
 320           break;
 321         ldinfo_offset += ldinfo.ldinfo_next;
 322       }
 323
 324     /* .vmdata sections from anonymously mmapped regions.  */
 325     if (coredata.c_vmregions)
 326       {
 327         int i;
 328
 329         if (bfd_seek (abfd, (file_ptr) coredata.c_vmm, SEEK_SET) != 0)
 330           return NULL;
 331
 332         for (i = 0; i < coredata.c_vmregions; i++)
 333           {
 334             struct vm_info vminfo;
 335
 336             if (bfd_read (&vminfo, sizeof (vminfo), 1, abfd) != sizeof (vminfo))
 337               return NULL;
 338             if (vminfo.vminfo_offset)
 339               {
 340                 if (!make_bfd_asection (abfd, ".vmdata",
 341                                         SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS,
 342                                         (bfd_size_type) vminfo.vminfo_size,
 343                                         (bfd_vma) vminfo.vminfo_addr,
 344                                         (file_ptr) vminfo.vminfo_offset))
 345                   return NULL;
 346               }
 347           }
 348       }
 349   }
 350 #endif
 351
 352   return abfd->xvec;                            /* this is garbage for now. */
 353 }
 354
 355
 356
 357 /* return `true' if given core is from the given executable.. */
 358 boolean
 359 rs6000coff_core_file_matches_executable_p (core_bfd, exec_bfd)
 360      bfd *core_bfd;
 361      bfd *exec_bfd;
 362 {
 363   struct core_dump coredata;
 364   struct ld_info ldinfo;
 365   bfd_size_type size;
 366   char *path, *s;
 367   size_t alloc;
 368   const char *str1, *str2;
 369   boolean ret;
 370
 371   if (bfd_seek (core_bfd, 0, SEEK_SET) != 0
 372       || bfd_read (&coredata, sizeof coredata, 1, core_bfd) != sizeof coredata)
 373     return false;
 374
 375   if (bfd_seek (core_bfd, (long) coredata.c_tab, SEEK_SET) != 0)
 376     return false;
 377
 378   size = (char *) &ldinfo.ldinfo_filename[0] - (char *) &ldinfo.ldinfo_next;
 379   if (bfd_read (&ldinfo, size, 1, core_bfd) != size)
 380     return false;
 381
 382   alloc = 100;
 383   path = bfd_malloc (alloc);
 384   if (path == NULL)
 385     return false;
 386   s = path;
 387
 388   while (1)
 389     {
 390       if (bfd_read (s, 1, 1, core_bfd) != 1)
 391         {
 392           free (path);
 393           return false;
 394         }
 395       if (*s == '\0')
 396         break;
 397       ++s;
 398       if (s == path + alloc)
 399         {
 400           char *n;
 401
 402           alloc *= 2;
 403           n = bfd_realloc (path, alloc);
 404           if (n == NULL)
 405             {
 406               free (path);
 407               return false;
 408             }
 409           s = n + (path - s);
 410           path = n;
 411         }
 412     }
 413
 414   str1 = strrchr (path, '/');
 415   str2 = strrchr (exec_bfd->filename, '/');
 416
 417   /* step over character '/' */
 418   str1 = str1 != NULL ? str1 + 1 : path;
 419   str2 = str2 != NULL ? str2 + 1 : exec_bfd->filename;
 420
 421   if (strcmp (str1, str2) == 0)
 422     ret = true;
 423   else
 424     ret = false;
 425
 426   free (path);
 427
 428   return ret;
 429 }
 430
 431 char *
 432 rs6000coff_core_file_failing_command (abfd)
 433      bfd *abfd;
 434 {
 435   char *com = core_hdr (abfd).CORE_COMM_FIELD;
 436   if (*com)
 437     return com;
 438   else
 439     return 0;
 440 }
 441
 442 int
 443 rs6000coff_core_file_failing_signal (abfd)
 444      bfd *abfd;
 445 {
 446   return core_hdr (abfd).c_signo;
 447 }
 448
 449
 450 boolean
 451 rs6000coff_get_section_contents (abfd, section, location, offset, count)
 452      bfd *abfd;
 453      sec_ptr section;
 454      PTR location;
 455      file_ptr offset;
 456      bfd_size_type count;
 457 {
 458     if (count == 0)
 459         return true;
 460
 461     /* Reading a core file's sections will be slightly different. For the
 462        rest of them we can use bfd_generic_get_section_contents () I suppose. */
 463     /* Make sure this routine works for any bfd and any section. FIXMEmgo. */
 464
 465     if (abfd->format == bfd_core && strcmp (section->name, ".reg") == 0) {
 466
 467       struct mstsave mstatus;
 468       int    regoffset = (char*)&mstatus.gpr[0] - (char*)&mstatus;
 469
 470       /* Assert that the only way this code will be executed is reading the
 471          whole section. */
 472       if (offset || count != (sizeof(mstatus.gpr) + (4 * NUM_OF_SPEC_REGS)))
 473         (*_bfd_error_handler)
 474           (_("ERROR! in rs6000coff_get_section_contents()\n"));
 475
 476       /* for `.reg' section, `filepos' is a pointer to the `mstsave' structure
 477          in the core file. */
 478
 479       /* read GPR's into the location. */
 480       if ( bfd_seek(abfd, section->filepos + regoffset, SEEK_SET) == -1
 481         || bfd_read(location, sizeof (mstatus.gpr), 1, abfd) != sizeof (mstatus.gpr))
 482         return (false); /* on error */
 483
 484       /* increment location to the beginning of special registers in the section,
 485          reset register offset value to the beginning of first special register
 486          in mstsave structure, and read special registers. */
 487
 488       location = (PTR) ((char*)location + sizeof (mstatus.gpr));
 489       regoffset = (char*)&mstatus.iar - (char*)&mstatus;
 490
 491       if ( bfd_seek(abfd, section->filepos + regoffset, SEEK_SET) == -1
 492         || bfd_read(location, 4 * NUM_OF_SPEC_REGS, 1, abfd) !=
 493                                                         4 * NUM_OF_SPEC_REGS)
 494         return (false); /* on error */
 495
 496       /* increment location address, and read the special registers.. */
 497       /* FIXMEmgo */
 498       return (true);
 499     }
 500
 501     /* else, use default bfd section content transfer. */
 502     else
 503       return _bfd_generic_get_section_contents
 504                         (abfd, section, location, offset, count);
 505 }
 506
 507 #endif /* AIX_CORE */