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. */ 75typedef 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 99typedef 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 111typedef 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 124typedef 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 259const bfd_target * rs6000coff_core_p (bfd *abfd); 260bfd_boolean rs6000coff_core_file_matches_executable_p (bfd *core_bfd, 261 bfd *exec_bfd); 262char * rs6000coff_core_file_failing_command (bfd *abfd); 263int 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 268static bfd_boolean 269read_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 291static asection * 292make_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 313const bfd_target * 314rs6000coff_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 641bfd_boolean 642rs6000coff_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 717char * 718rs6000coff_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 730int 731rs6000coff_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 */ 738