aoutf1.h revision 60484
1100966Siwasaki/* A.out "format 1" file handling code for BFD. 2100966Siwasaki Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 1998 3100966Siwasaki Free Software Foundation, Inc. 4100966Siwasaki Written by Cygnus Support. 5128212Snjl 6100966SiwasakiThis file is part of BFD, the Binary File Descriptor library. 7100966Siwasaki 8100966SiwasakiThis program is free software; you can redistribute it and/or modify 9100966Siwasakiit under the terms of the GNU General Public License as published by 10100966Siwasakithe Free Software Foundation; either version 2 of the License, or 11100966Siwasaki(at your option) any later version. 12100966Siwasaki 13126372SnjlThis program is distributed in the hope that it will be useful, 14100966Siwasakibut WITHOUT ANY WARRANTY; without even the implied warranty of 15100966SiwasakiMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16100966SiwasakiGNU General Public License for more details. 17100966Siwasaki 18100966SiwasakiYou should have received a copy of the GNU General Public License 19100966Siwasakialong with this program; if not, write to the Free Software 20100966SiwasakiFoundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 21100966Siwasaki 22100966Siwasaki#include "bfd.h" 23100966Siwasaki#include "sysdep.h" 24100966Siwasaki#include "libbfd.h" 25100966Siwasaki 26100966Siwasaki#include "aout/sun4.h" 27100966Siwasaki#include "libaout.h" /* BFD a.out internal data structures */ 28100966Siwasaki 29100966Siwasaki#include "aout/aout64.h" 30100966Siwasaki#include "aout/stab_gnu.h" 31100966Siwasaki#include "aout/ar.h" 32100966Siwasaki 33100966Siwasaki/* This is needed to reject a NewsOS file, e.g. in 34100966Siwasaki gdb/testsuite/gdb.t10/crossload.exp. <kingdon@cygnus.com> 35100966Siwasaki I needed to add M_UNKNOWN to recognize a 68000 object, so this will 36100966Siwasaki probably no longer reject a NewsOS object. <ian@cygnus.com>. */ 37100966Siwasaki#ifndef MACHTYPE_OK 38100966Siwasaki#define MACHTYPE_OK(mtype) \ 39100966Siwasaki (((mtype) == M_SPARC && bfd_lookup_arch (bfd_arch_sparc, 0) != NULL) \ 40100966Siwasaki || (((mtype) == M_UNKNOWN || (mtype) == M_68010 || (mtype) == M_68020) \ 41100966Siwasaki && bfd_lookup_arch (bfd_arch_m68k, 0) != NULL)) 42100966Siwasaki#endif 43100966Siwasaki 44100966Siwasaki/* 45100966SiwasakiThe file @code{aoutf1.h} contains the code for BFD's 46100966Siwasakia.out back end. Control over the generated back end is given by these 47100966Siwasakitwo preprocessor names: 48100966Siwasaki@table @code 49100966Siwasaki@item ARCH_SIZE 50100966SiwasakiThis value should be either 32 or 64, depending upon the size of an 51100966Siwasakiint in the target format. It changes the sizes of the structs which 52100966Siwasakiperform the memory/disk mapping of structures. 53100966Siwasaki 54100966SiwasakiThe 64 bit backend may only be used if the host compiler supports 64 55100966Siwasakiints (eg long long with gcc), by defining the name @code{BFD_HOST_64_BIT} in @code{bfd.h}. 56100966SiwasakiWith this name defined, @emph{all} bfd operations are performed with 64bit 57100966Siwasakiarithmetic, not just those to a 64bit target. 58100966Siwasaki 59100966Siwasaki@item TARGETNAME 60100966SiwasakiThe name put into the target vector. 61100966Siwasaki@item 62100966Siwasaki@end table 63100966Siwasaki 64100966Siwasaki*/ 65100966Siwasaki 66100966Siwasaki/*SUPPRESS558*/ 67100966Siwasaki/*SUPPRESS529*/ 68100966Siwasaki 69100966Siwasaki#if ARCH_SIZE == 64 70100966Siwasaki#define sunos_set_arch_mach sunos_64_set_arch_mach 71100966Siwasaki#define sunos_write_object_contents aout_64_sunos4_write_object_contents 72100966Siwasaki#else 73100966Siwasaki#define sunos_set_arch_mach sunos_32_set_arch_mach 74100966Siwasaki#define sunos_write_object_contents aout_32_sunos4_write_object_contents 75100966Siwasaki#endif 76100966Siwasaki 77100966Siwasakistatic boolean sunos_merge_private_bfd_data PARAMS ((bfd *, bfd *)); 78100966Siwasakistatic void sunos_set_arch_mach PARAMS ((bfd *, int)); 79100966Siwasakistatic void choose_reloc_size PARAMS ((bfd *)); 80100966Siwasakistatic boolean sunos_write_object_contents PARAMS ((bfd *)); 81100966Siwasakistatic const bfd_target *sunos4_core_file_p PARAMS ((bfd *)); 82100966Siwasakistatic char *sunos4_core_file_failing_command PARAMS ((bfd *)); 83100966Siwasakistatic int sunos4_core_file_failing_signal PARAMS ((bfd *)); 84100966Siwasakistatic boolean sunos4_core_file_matches_executable_p PARAMS ((bfd *, bfd *)); 85100966Siwasakistatic boolean sunos4_set_sizes PARAMS ((bfd *)); 86100966Siwasaki 87100966Siwasaki/* Merge backend data into the output file. 88100966Siwasaki This is necessary on sparclet-aout where we want the resultant machine 89100966Siwasaki number to be M_SPARCLET if any input file is M_SPARCLET. */ 90100966Siwasaki 91100966Siwasaki#define MY_bfd_merge_private_bfd_data sunos_merge_private_bfd_data 92100966Siwasaki 93100966Siwasakistatic boolean 94100966Siwasakisunos_merge_private_bfd_data (ibfd, obfd) 95100966Siwasaki bfd *ibfd, *obfd; 96100966Siwasaki{ 97100966Siwasaki if (bfd_get_flavour (ibfd) != bfd_target_aout_flavour 98100966Siwasaki || bfd_get_flavour (obfd) != bfd_target_aout_flavour) 99100966Siwasaki return true; 100100966Siwasaki 101100966Siwasaki if (bfd_get_arch (obfd) == bfd_arch_sparc) 102100966Siwasaki { 103100966Siwasaki if (bfd_get_mach (obfd) < bfd_get_mach (ibfd)) 104100966Siwasaki bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd)); 105100966Siwasaki } 106100966Siwasaki 107100966Siwasaki return true; 108100966Siwasaki} 109100966Siwasaki 110100966Siwasaki/* This is either sunos_32_set_arch_mach or sunos_64_set_arch_mach, 111100966Siwasaki depending upon ARCH_SIZE. */ 112100966Siwasaki 113100966Siwasakistatic void 114100966Siwasakisunos_set_arch_mach (abfd, machtype) 115100966Siwasaki bfd *abfd; 116100966Siwasaki int machtype; 117100966Siwasaki{ 118100966Siwasaki /* Determine the architecture and machine type of the object file. */ 119100966Siwasaki enum bfd_architecture arch; 120100966Siwasaki long machine; 121100966Siwasaki switch (machtype) 122100966Siwasaki { 123128212Snjl 124100966Siwasaki case M_UNKNOWN: 125100966Siwasaki /* Some Sun3s make magic numbers without cpu types in them, so 126100966Siwasaki we'll default to the 68000. */ 127100966Siwasaki arch = bfd_arch_m68k; 128100966Siwasaki machine = bfd_mach_m68000; 129100966Siwasaki break; 130100966Siwasaki 131100966Siwasaki case M_68010: 132100966Siwasaki case M_HP200: 133100966Siwasaki arch = bfd_arch_m68k; 134100966Siwasaki machine = bfd_mach_m68010; 135100966Siwasaki break; 136100966Siwasaki 137100966Siwasaki case M_68020: 138100966Siwasaki case M_HP300: 139100966Siwasaki arch = bfd_arch_m68k; 140100966Siwasaki machine = bfd_mach_m68020; 141100966Siwasaki break; 142100966Siwasaki 143100966Siwasaki case M_SPARC: 144100966Siwasaki arch = bfd_arch_sparc; 145100966Siwasaki machine = 0; 146100966Siwasaki break; 147100966Siwasaki 148100966Siwasaki case M_SPARCLET: 149100966Siwasaki arch = bfd_arch_sparc; 150100966Siwasaki machine = bfd_mach_sparc_sparclet; 151100966Siwasaki break; 152100966Siwasaki 153100966Siwasaki case M_SPARCLITE_LE: 154100966Siwasaki arch = bfd_arch_sparc; 155100966Siwasaki machine = bfd_mach_sparc_sparclite_le; 156100966Siwasaki break; 157100966Siwasaki 158100966Siwasaki case M_386: 159100966Siwasaki case M_386_DYNIX: 160100966Siwasaki arch = bfd_arch_i386; 161100966Siwasaki machine = 0; 162100966Siwasaki break; 163100966Siwasaki 164100966Siwasaki case M_29K: 165100966Siwasaki arch = bfd_arch_a29k; 166100966Siwasaki machine = 0; 167100966Siwasaki break; 168100966Siwasaki 169100966Siwasaki case M_HPUX: 170100966Siwasaki arch = bfd_arch_m68k; 171100966Siwasaki machine = 0; 172100966Siwasaki break; 173100966Siwasaki 174100966Siwasaki default: 175100966Siwasaki arch = bfd_arch_obscure; 176100966Siwasaki machine = 0; 177100966Siwasaki break; 178100966Siwasaki } 179100966Siwasaki bfd_set_arch_mach (abfd, arch, machine); 180100966Siwasaki} 181100966Siwasaki 182100966Siwasaki#define SET_ARCH_MACH(ABFD, EXEC) \ 183100966Siwasaki NAME(sunos,set_arch_mach)(ABFD, N_MACHTYPE (EXEC)); \ 184100966Siwasaki choose_reloc_size(ABFD); 185100966Siwasaki 186100966Siwasaki/* Determine the size of a relocation entry, based on the architecture */ 187100966Siwasakistatic void 188100966Siwasakichoose_reloc_size (abfd) 189100966Siwasaki bfd *abfd; 190100966Siwasaki{ 191100966Siwasaki switch (bfd_get_arch (abfd)) 192100966Siwasaki { 193100966Siwasaki case bfd_arch_sparc: 194100966Siwasaki case bfd_arch_a29k: 195100966Siwasaki obj_reloc_entry_size (abfd) = RELOC_EXT_SIZE; 196100966Siwasaki break; 197100966Siwasaki default: 198100966Siwasaki obj_reloc_entry_size (abfd) = RELOC_STD_SIZE; 199100966Siwasaki break; 200100966Siwasaki } 201100966Siwasaki} 202100966Siwasaki 203100966Siwasaki/* Write an object file in SunOS format. Section contents have 204100966Siwasaki already been written. We write the file header, symbols, and 205100966Siwasaki relocation. The real name of this function is either 206100966Siwasaki aout_64_sunos4_write_object_contents or 207100966Siwasaki aout_32_sunos4_write_object_contents, depending upon ARCH_SIZE. */ 208100966Siwasaki 209100966Siwasakistatic boolean 210100966Siwasakisunos_write_object_contents (abfd) 211100966Siwasaki bfd *abfd; 212100966Siwasaki{ 213100966Siwasaki struct external_exec exec_bytes; 214100966Siwasaki struct internal_exec *execp = exec_hdr (abfd); 215100966Siwasaki 216100966Siwasaki /* Magic number, maestro, please! */ 217100966Siwasaki switch (bfd_get_arch (abfd)) 218100966Siwasaki { 219100966Siwasaki case bfd_arch_m68k: 220100966Siwasaki switch (bfd_get_mach (abfd)) 221100966Siwasaki { 222100966Siwasaki case bfd_mach_m68000: 223100966Siwasaki N_SET_MACHTYPE (*execp, M_UNKNOWN); 224100966Siwasaki break; 225100966Siwasaki case bfd_mach_m68010: 226100966Siwasaki N_SET_MACHTYPE (*execp, M_68010); 227100966Siwasaki break; 228100966Siwasaki default: 229100966Siwasaki case bfd_mach_m68020: 230100966Siwasaki N_SET_MACHTYPE (*execp, M_68020); 231100966Siwasaki break; 232100966Siwasaki } 233100966Siwasaki break; 234100966Siwasaki case bfd_arch_sparc: 235128212Snjl switch (bfd_get_mach (abfd)) 236128212Snjl { 237100966Siwasaki case bfd_mach_sparc_sparclet: 238100966Siwasaki N_SET_MACHTYPE (*execp, M_SPARCLET); 239128212Snjl break; 240100966Siwasaki case bfd_mach_sparc_sparclite_le: 241100966Siwasaki N_SET_MACHTYPE (*execp, M_SPARCLITE_LE); 242100966Siwasaki break; 243100966Siwasaki default: 244100966Siwasaki N_SET_MACHTYPE (*execp, M_SPARC); 245100966Siwasaki break; 246100966Siwasaki } 247100966Siwasaki break; 248100966Siwasaki case bfd_arch_i386: 249100966Siwasaki N_SET_MACHTYPE (*execp, M_386); 250100966Siwasaki break; 251100966Siwasaki case bfd_arch_a29k: 252100966Siwasaki N_SET_MACHTYPE (*execp, M_29K); 253100966Siwasaki break; 254100966Siwasaki default: 255100966Siwasaki N_SET_MACHTYPE (*execp, M_UNKNOWN); 256100966Siwasaki } 257100966Siwasaki 258128212Snjl choose_reloc_size (abfd); 259100966Siwasaki 260100966Siwasaki N_SET_FLAGS (*execp, aout_backend_info (abfd)->exec_hdr_flags); 261100966Siwasaki 262100966Siwasaki N_SET_DYNAMIC (*execp, bfd_get_file_flags (abfd) & DYNAMIC); 263100966Siwasaki 264100966Siwasaki WRITE_HEADERS (abfd, execp); 265100966Siwasaki 266100966Siwasaki return true; 267100966Siwasaki} 268100966Siwasaki 269100966Siwasaki/* core files */ 270100966Siwasaki 271100966Siwasaki#define CORE_MAGIC 0x080456 272100966Siwasaki#define CORE_NAMELEN 16 273100966Siwasaki 274100966Siwasaki/* The core structure is taken from the Sun documentation. 275100966Siwasaki Unfortunately, they don't document the FPA structure, or at least I 276100966Siwasaki can't find it easily. Fortunately the core header contains its own 277100966Siwasaki length. So this shouldn't cause problems, except for c_ucode, which 278100966Siwasaki so far we don't use but is easy to find with a little arithmetic. */ 279100966Siwasaki 280100966Siwasaki/* But the reg structure can be gotten from the SPARC processor handbook. 281100966Siwasaki This really should be in a GNU include file though so that gdb can use 282100966Siwasaki the same info. */ 283100966Siwasakistruct regs 284100966Siwasaki{ 285100966Siwasaki int r_psr; 286100966Siwasaki int r_pc; 287100966Siwasaki int r_npc; 288100966Siwasaki int r_y; 289100966Siwasaki int r_g1; 290100966Siwasaki int r_g2; 291100966Siwasaki int r_g3; 292100966Siwasaki int r_g4; 293128212Snjl int r_g5; 294100966Siwasaki int r_g6; 295100966Siwasaki int r_g7; 296100966Siwasaki int r_o0; 297100966Siwasaki int r_o1; 298100966Siwasaki int r_o2; 299100966Siwasaki int r_o3; 300100966Siwasaki int r_o4; 301100966Siwasaki int r_o5; 302100966Siwasaki int r_o6; 303100966Siwasaki int r_o7; 304100966Siwasaki}; 305100966Siwasaki 306100966Siwasaki/* Taken from Sun documentation: */ 307100966Siwasaki 308100966Siwasaki/* FIXME: It's worse than we expect. This struct contains TWO substructs 309100966Siwasaki neither of whose size we know, WITH STUFF IN BETWEEN THEM! We can't 310100966Siwasaki even portably access the stuff in between! */ 311100966Siwasaki 312100966Siwasakistruct external_sparc_core 313100966Siwasaki { 314100966Siwasaki int c_magic; /* Corefile magic number */ 315100966Siwasaki int c_len; /* Sizeof (struct core) */ 316100966Siwasaki#define SPARC_CORE_LEN 432 317100966Siwasaki int c_regs[19]; /* General purpose registers -- MACHDEP SIZE */ 318100966Siwasaki struct external_exec c_aouthdr; /* A.out header */ 319100966Siwasaki int c_signo; /* Killing signal, if any */ 320100966Siwasaki int c_tsize; /* Text size (bytes) */ 321100966Siwasaki int c_dsize; /* Data size (bytes) */ 322100966Siwasaki int c_ssize; /* Stack size (bytes) */ 323100966Siwasaki char c_cmdname[CORE_NAMELEN + 1]; /* Command name */ 324100966Siwasaki double fp_stuff[1]; /* external FPU state (size unknown by us) */ 325100966Siwasaki /* The type "double" is critical here, for alignment. 326100966Siwasaki SunOS declares a struct here, but the struct's alignment 327100966Siwasaki is double since it contains doubles. */ 328100966Siwasaki int c_ucode; /* Exception no. from u_code */ 329100966Siwasaki /* (this member is not accessible by name since we don't 330100966Siwasaki portably know the size of fp_stuff.) */ 331100966Siwasaki }; 332100966Siwasaki 333100966Siwasaki/* Core files generated by the BCP (the part of Solaris which allows 334100966Siwasaki it to run SunOS4 a.out files). */ 335100966Siwasakistruct external_solaris_bcp_core 336100966Siwasaki { 337100966Siwasaki int c_magic; /* Corefile magic number */ 338100966Siwasaki int c_len; /* Sizeof (struct core) */ 339100966Siwasaki#define SOLARIS_BCP_CORE_LEN 456 340100966Siwasaki int c_regs[19]; /* General purpose registers -- MACHDEP SIZE */ 341100966Siwasaki int c_exdata_vp; /* exdata structure */ 342100966Siwasaki int c_exdata_tsize; 343100966Siwasaki int c_exdata_dsize; 344100966Siwasaki int c_exdata_bsize; 345100966Siwasaki int c_exdata_lsize; 346100966Siwasaki int c_exdata_nshlibs; 347100966Siwasaki short c_exdata_mach; 348100966Siwasaki short c_exdata_mag; 349100966Siwasaki int c_exdata_toffset; 350100966Siwasaki int c_exdata_doffset; 351100966Siwasaki int c_exdata_loffset; 352100966Siwasaki int c_exdata_txtorg; 353100966Siwasaki int c_exdata_datorg; 354100966Siwasaki int c_exdata_entloc; 355100966Siwasaki int c_signo; /* Killing signal, if any */ 356100966Siwasaki int c_tsize; /* Text size (bytes) */ 357100966Siwasaki int c_dsize; /* Data size (bytes) */ 358100966Siwasaki int c_ssize; /* Stack size (bytes) */ 359100966Siwasaki char c_cmdname[CORE_NAMELEN + 1]; /* Command name */ 360100966Siwasaki double fp_stuff[1]; /* external FPU state (size unknown by us) */ 361100966Siwasaki /* The type "double" is critical here, for alignment. 362100966Siwasaki SunOS declares a struct here, but the struct's alignment 363100966Siwasaki is double since it contains doubles. */ 364100966Siwasaki int c_ucode; /* Exception no. from u_code */ 365100966Siwasaki /* (this member is not accessible by name since we don't 366100966Siwasaki portably know the size of fp_stuff.) */ 367100966Siwasaki }; 368100966Siwasaki 369100966Siwasakistruct external_sun3_core 370100966Siwasaki { 371100966Siwasaki int c_magic; /* Corefile magic number */ 372100966Siwasaki int c_len; /* Sizeof (struct core) */ 373100966Siwasaki#define SUN3_CORE_LEN 826 /* As of SunOS 4.1.1 */ 374100966Siwasaki int c_regs[18]; /* General purpose registers -- MACHDEP SIZE */ 375100966Siwasaki struct external_exec c_aouthdr; /* A.out header */ 376100966Siwasaki int c_signo; /* Killing signal, if any */ 377100966Siwasaki int c_tsize; /* Text size (bytes) */ 378100966Siwasaki int c_dsize; /* Data size (bytes) */ 379100966Siwasaki int c_ssize; /* Stack size (bytes) */ 380100966Siwasaki char c_cmdname[CORE_NAMELEN + 1]; /* Command name */ 381100966Siwasaki double fp_stuff[1]; /* external FPU state (size unknown by us) */ 382100966Siwasaki /* The type "double" is critical here, for alignment. 383100966Siwasaki SunOS declares a struct here, but the struct's alignment 384100966Siwasaki is double since it contains doubles. */ 385100966Siwasaki int c_ucode; /* Exception no. from u_code */ 386100966Siwasaki /* (this member is not accessible by name since we don't 387100966Siwasaki portably know the size of fp_stuff.) */ 388100966Siwasaki }; 389100966Siwasaki 390100966Siwasakistruct internal_sunos_core 391100966Siwasaki { 392100966Siwasaki int c_magic; /* Corefile magic number */ 393100966Siwasaki int c_len; /* Sizeof (struct core) */ 394100966Siwasaki long c_regs_pos; /* file offset of General purpose registers */ 395100966Siwasaki int c_regs_size; /* size of General purpose registers */ 396100966Siwasaki struct internal_exec c_aouthdr; /* A.out header */ 397100966Siwasaki int c_signo; /* Killing signal, if any */ 398100966Siwasaki int c_tsize; /* Text size (bytes) */ 399100966Siwasaki int c_dsize; /* Data size (bytes) */ 400100966Siwasaki bfd_vma c_data_addr; /* Data start (address) */ 401100966Siwasaki int c_ssize; /* Stack size (bytes) */ 402100966Siwasaki bfd_vma c_stacktop; /* Stack top (address) */ 403100966Siwasaki char c_cmdname[CORE_NAMELEN + 1]; /* Command name */ 404100966Siwasaki long fp_stuff_pos; /* file offset of external FPU state (regs) */ 405100966Siwasaki int fp_stuff_size; /* Size of it */ 406100966Siwasaki int c_ucode; /* Exception no. from u_code */ 407100966Siwasaki }; 408100966Siwasaki 409100966Siwasakistatic void swapcore_sun3 410100966Siwasaki PARAMS ((bfd *, char *, struct internal_sunos_core *)); 411100966Siwasakistatic void swapcore_sparc 412100966Siwasaki PARAMS ((bfd *, char *, struct internal_sunos_core *)); 413100966Siwasakistatic void swapcore_solaris_bcp 414100966Siwasaki PARAMS ((bfd *, char *, struct internal_sunos_core *)); 415100966Siwasaki 416100966Siwasaki/* byte-swap in the Sun-3 core structure */ 417100966Siwasakistatic void 418100966Siwasakiswapcore_sun3 (abfd, ext, intcore) 419100966Siwasaki bfd *abfd; 420100966Siwasaki char *ext; 421100966Siwasaki struct internal_sunos_core *intcore; 422100966Siwasaki{ 423100966Siwasaki struct external_sun3_core *extcore = (struct external_sun3_core *) ext; 424100966Siwasaki 425100966Siwasaki intcore->c_magic = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_magic); 426100966Siwasaki intcore->c_len = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_len); 427100966Siwasaki intcore->c_regs_pos = (long) (((struct external_sun3_core *) 0)->c_regs); 428100966Siwasaki intcore->c_regs_size = sizeof (extcore->c_regs); 429128212Snjl#if ARCH_SIZE == 64 430128212Snjl aout_64_swap_exec_header_in 431128212Snjl#else 432100966Siwasaki aout_32_swap_exec_header_in 433128212Snjl#endif 434128212Snjl (abfd, &extcore->c_aouthdr, &intcore->c_aouthdr); 435128212Snjl intcore->c_signo = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_signo); 436128212Snjl intcore->c_tsize = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_tsize); 437128212Snjl intcore->c_dsize = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_dsize); 438128212Snjl intcore->c_data_addr = N_DATADDR (intcore->c_aouthdr); 439128212Snjl intcore->c_ssize = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_ssize); 440128212Snjl memcpy (intcore->c_cmdname, extcore->c_cmdname, sizeof (intcore->c_cmdname)); 441128212Snjl intcore->fp_stuff_pos = (long) (((struct external_sun3_core *) 0)->fp_stuff); 442128212Snjl /* FP stuff takes up whole rest of struct, except c_ucode. */ 443100966Siwasaki intcore->fp_stuff_size = intcore->c_len - (sizeof extcore->c_ucode) - 444100966Siwasaki (file_ptr) (((struct external_sun3_core *) 0)->fp_stuff); 445100966Siwasaki /* Ucode is the last thing in the struct -- just before the end */ 446100966Siwasaki intcore->c_ucode = 447100966Siwasaki bfd_h_get_32 (abfd, 448100966Siwasaki intcore->c_len - sizeof (extcore->c_ucode) + (unsigned char *) extcore); 449100966Siwasaki intcore->c_stacktop = 0x0E000000; /* By experimentation */ 450100966Siwasaki} 451100966Siwasaki 452100966Siwasaki 453100966Siwasaki/* byte-swap in the Sparc core structure */ 454100966Siwasakistatic void 455100966Siwasakiswapcore_sparc (abfd, ext, intcore) 456100966Siwasaki bfd *abfd; 457100966Siwasaki char *ext; 458100966Siwasaki struct internal_sunos_core *intcore; 459100966Siwasaki{ 460100966Siwasaki struct external_sparc_core *extcore = (struct external_sparc_core *) ext; 461100966Siwasaki 462100966Siwasaki intcore->c_magic = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_magic); 463100966Siwasaki intcore->c_len = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_len); 464100966Siwasaki intcore->c_regs_pos = (long) (((struct external_sparc_core *) 0)->c_regs); 465100966Siwasaki intcore->c_regs_size = sizeof (extcore->c_regs); 466100966Siwasaki#if ARCH_SIZE == 64 467100966Siwasaki aout_64_swap_exec_header_in 468100966Siwasaki#else 469100966Siwasaki aout_32_swap_exec_header_in 470100966Siwasaki#endif 471100966Siwasaki (abfd, &extcore->c_aouthdr, &intcore->c_aouthdr); 472100966Siwasaki intcore->c_signo = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_signo); 473100966Siwasaki intcore->c_tsize = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_tsize); 474100966Siwasaki intcore->c_dsize = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_dsize); 475100966Siwasaki intcore->c_data_addr = N_DATADDR (intcore->c_aouthdr); 476100966Siwasaki intcore->c_ssize = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_ssize); 477100966Siwasaki memcpy (intcore->c_cmdname, extcore->c_cmdname, sizeof (intcore->c_cmdname)); 478100966Siwasaki intcore->fp_stuff_pos = (long) (((struct external_sparc_core *) 0)->fp_stuff); 479100966Siwasaki /* FP stuff takes up whole rest of struct, except c_ucode. */ 480100966Siwasaki intcore->fp_stuff_size = intcore->c_len - (sizeof extcore->c_ucode) - 481100966Siwasaki (file_ptr) (((struct external_sparc_core *) 0)->fp_stuff); 482100966Siwasaki /* Ucode is the last thing in the struct -- just before the end */ 483100966Siwasaki intcore->c_ucode = 484100966Siwasaki bfd_h_get_32 (abfd, 485100966Siwasaki intcore->c_len - sizeof (extcore->c_ucode) + (unsigned char *) extcore); 486100966Siwasaki 487100966Siwasaki /* Supposedly the user stack grows downward from the bottom of kernel memory. 488100966Siwasaki Presuming that this remains true, this definition will work. */ 489100966Siwasaki /* Now sun has provided us with another challenge. The value is different 490100966Siwasaki for sparc2 and sparc10 (both running SunOS 4.1.3). We pick one or 491100966Siwasaki the other based on the current value of the stack pointer. This 492100966Siwasaki loses (a) if the stack pointer has been clobbered, or (b) if the stack 493100966Siwasaki is larger than 128 megabytes. 494100966Siwasaki 495100966Siwasaki It's times like these you're glad they're switching to ELF. 496100966Siwasaki 497100966Siwasaki Note that using include files or nlist on /vmunix would be wrong, 498100966Siwasaki because we want the value for this core file, no matter what kind of 499100966Siwasaki machine we were compiled on or are running on. */ 500100966Siwasaki#define SPARC_USRSTACK_SPARC2 ((bfd_vma)0xf8000000) 501100966Siwasaki#define SPARC_USRSTACK_SPARC10 ((bfd_vma)0xf0000000) 502100966Siwasaki { 503100966Siwasaki bfd_vma sp = bfd_h_get_32 504100966Siwasaki (abfd, (unsigned char *) &((struct regs *) &extcore->c_regs[0])->r_o6); 505100966Siwasaki if (sp < SPARC_USRSTACK_SPARC10) 506107325Siwasaki intcore->c_stacktop = SPARC_USRSTACK_SPARC10; 507107325Siwasaki else 508100966Siwasaki intcore->c_stacktop = SPARC_USRSTACK_SPARC2; 509100966Siwasaki } 510100966Siwasaki} 511100966Siwasaki 512100966Siwasaki/* byte-swap in the Solaris BCP core structure */ 513100966Siwasakistatic void 514100966Siwasakiswapcore_solaris_bcp (abfd, ext, intcore) 515100966Siwasaki bfd *abfd; 516100966Siwasaki char *ext; 517100966Siwasaki struct internal_sunos_core *intcore; 518100966Siwasaki{ 519100966Siwasaki struct external_solaris_bcp_core *extcore = 520100966Siwasaki (struct external_solaris_bcp_core *) ext; 521100966Siwasaki 522100966Siwasaki intcore->c_magic = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_magic); 523100966Siwasaki intcore->c_len = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_len); 524100966Siwasaki intcore->c_regs_pos = (long) (((struct external_solaris_bcp_core *) 0)->c_regs); 525100966Siwasaki intcore->c_regs_size = sizeof (extcore->c_regs); 526100966Siwasaki 527100966Siwasaki /* The Solaris BCP exdata structure does not contain an a_syms field, 528100966Siwasaki so we are unable to synthesize an internal exec header. 529100966Siwasaki Luckily we are able to figure out the start address of the data section, 530100966Siwasaki which is the only thing needed from the internal exec header, 531100966Siwasaki from the exdata structure. 532100966Siwasaki 533100966Siwasaki As of Solaris 2.3, BCP core files for statically linked executables 534100966Siwasaki are buggy. The exdata structure is not properly filled in, and 535100966Siwasaki the data section is written from address zero instead of the data 536100966Siwasaki start address. */ 537100966Siwasaki memset ((PTR) &intcore->c_aouthdr, 0, sizeof (struct internal_exec)); 538100966Siwasaki intcore->c_data_addr = 539100966Siwasaki bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_exdata_datorg); 540100966Siwasaki intcore->c_signo = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_signo); 541100966Siwasaki intcore->c_tsize = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_tsize); 542100966Siwasaki intcore->c_dsize = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_dsize); 543100966Siwasaki intcore->c_ssize = bfd_h_get_32 (abfd, (unsigned char *) &extcore->c_ssize); 544100966Siwasaki memcpy (intcore->c_cmdname, extcore->c_cmdname, sizeof (intcore->c_cmdname)); 545100966Siwasaki intcore->fp_stuff_pos = 546100966Siwasaki (long) (((struct external_solaris_bcp_core *) 0)->fp_stuff); 547100966Siwasaki /* FP stuff takes up whole rest of struct, except c_ucode. */ 548100966Siwasaki intcore->fp_stuff_size = intcore->c_len - (sizeof extcore->c_ucode) - 549100966Siwasaki (file_ptr) (((struct external_solaris_bcp_core *) 0)->fp_stuff); 550100966Siwasaki /* Ucode is the last thing in the struct -- just before the end */ 551100966Siwasaki intcore->c_ucode = 552100966Siwasaki bfd_h_get_32 (abfd, 553100966Siwasaki intcore->c_len - sizeof (extcore->c_ucode) + (unsigned char *) extcore); 554117521Snjl 555100966Siwasaki /* Supposedly the user stack grows downward from the bottom of kernel memory. 556100966Siwasaki Presuming that this remains true, this definition will work. */ 557100966Siwasaki /* Now sun has provided us with another challenge. The value is different 558100966Siwasaki for sparc2 and sparc10 (both running SunOS 4.1.3). We pick one or 559117521Snjl the other based on the current value of the stack pointer. This 560117521Snjl loses (a) if the stack pointer has been clobbered, or (b) if the stack 561100966Siwasaki is larger than 128 megabytes. 562100966Siwasaki 563100966Siwasaki It's times like these you're glad they're switching to ELF. 564100966Siwasaki 565100966Siwasaki Note that using include files or nlist on /vmunix would be wrong, 566100966Siwasaki because we want the value for this core file, no matter what kind of 567100966Siwasaki machine we were compiled on or are running on. */ 568100966Siwasaki#define SPARC_USRSTACK_SPARC2 ((bfd_vma)0xf8000000) 569100966Siwasaki#define SPARC_USRSTACK_SPARC10 ((bfd_vma)0xf0000000) 570100966Siwasaki { 571100966Siwasaki bfd_vma sp = bfd_h_get_32 572100966Siwasaki (abfd, (unsigned char *) &((struct regs *) &extcore->c_regs[0])->r_o6); 573100966Siwasaki if (sp < SPARC_USRSTACK_SPARC10) 574100966Siwasaki intcore->c_stacktop = SPARC_USRSTACK_SPARC10; 575100966Siwasaki else 576100966Siwasaki intcore->c_stacktop = SPARC_USRSTACK_SPARC2; 577100966Siwasaki } 578100966Siwasaki} 579100966Siwasaki 580100966Siwasaki/* need this cast because ptr is really void * */ 581117521Snjl#define core_hdr(bfd) ((bfd)->tdata.sun_core_data) 582117521Snjl#define core_datasec(bfd) (core_hdr(bfd)->data_section) 583100966Siwasaki#define core_stacksec(bfd) (core_hdr(bfd)->stack_section) 584100966Siwasaki#define core_regsec(bfd) (core_hdr(bfd)->reg_section) 585100966Siwasaki#define core_reg2sec(bfd) (core_hdr(bfd)->reg2_section) 586100966Siwasaki 587100966Siwasaki/* These are stored in the bfd's tdata */ 588100966Siwasakistruct sun_core_struct 589100966Siwasaki{ 590100966Siwasaki struct internal_sunos_core *hdr; /* core file header */ 591100966Siwasaki asection *data_section; 592117521Snjl asection *stack_section; 593100966Siwasaki asection *reg_section; 594100966Siwasaki asection *reg2_section; 595100966Siwasaki}; 596117521Snjl 597117521Snjlstatic const bfd_target * 598100966Siwasakisunos4_core_file_p (abfd) 599100966Siwasaki bfd *abfd; 600100966Siwasaki{ 601100966Siwasaki unsigned char longbuf[4]; /* Raw bytes of various header fields */ 602100966Siwasaki bfd_size_type core_size; 603100966Siwasaki unsigned long core_mag; 604100966Siwasaki struct internal_sunos_core *core; 605100966Siwasaki char *extcore; 606100966Siwasaki struct mergem 607100966Siwasaki { 608100966Siwasaki struct sun_core_struct suncoredata; 609100966Siwasaki struct internal_sunos_core internal_sunos_core; 610117521Snjl char external_core[1]; 611100966Siwasaki } 612117521Snjl *mergem; 613117521Snjl 614100966Siwasaki if (bfd_read ((PTR) longbuf, 1, sizeof (longbuf), abfd) != 615100966Siwasaki sizeof (longbuf)) 616100966Siwasaki return 0; 617100966Siwasaki core_mag = bfd_h_get_32 (abfd, longbuf); 618100966Siwasaki 619100966Siwasaki if (core_mag != CORE_MAGIC) 620100966Siwasaki return 0; 621100966Siwasaki 622100966Siwasaki /* SunOS core headers can vary in length; second word is size; */ 623100966Siwasaki if (bfd_read ((PTR) longbuf, 1, sizeof (longbuf), abfd) != 624117521Snjl sizeof (longbuf)) 625100966Siwasaki return 0; 626117521Snjl core_size = bfd_h_get_32 (abfd, longbuf); 627100966Siwasaki /* Sanity check */ 628117521Snjl if (core_size > 20000) 629117521Snjl return 0; 630117521Snjl 631117521Snjl if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) < 0) 632117521Snjl return 0; 633117521Snjl 634100966Siwasaki mergem = (struct mergem *) bfd_zalloc (abfd, core_size + sizeof (struct mergem)); 635117521Snjl if (mergem == NULL) 636100966Siwasaki return 0; 637100966Siwasaki 638100966Siwasaki extcore = mergem->external_core; 639100966Siwasaki 640100966Siwasaki if ((bfd_read ((PTR) extcore, 1, core_size, abfd)) != core_size) 641100966Siwasaki { 642100966Siwasaki bfd_release (abfd, (char *) mergem); 643100966Siwasaki return 0; 644100966Siwasaki } 645100966Siwasaki 646100966Siwasaki /* Validate that it's a core file we know how to handle, due to sun 647100966Siwasaki botching the positioning of registers and other fields in a machine 648100966Siwasaki dependent way. */ 649100966Siwasaki core = &mergem->internal_sunos_core; 650100966Siwasaki switch (core_size) 651100966Siwasaki { 652100966Siwasaki case SPARC_CORE_LEN: 653100966Siwasaki swapcore_sparc (abfd, extcore, core); 654100966Siwasaki break; 655100966Siwasaki case SUN3_CORE_LEN: 656100966Siwasaki swapcore_sun3 (abfd, extcore, core); 657100966Siwasaki break; 658100966Siwasaki case SOLARIS_BCP_CORE_LEN: 659117521Snjl swapcore_solaris_bcp (abfd, extcore, core); 660117521Snjl break; 661100966Siwasaki default: 662100966Siwasaki bfd_set_error (bfd_error_system_call); /* FIXME */ 663100966Siwasaki bfd_release (abfd, (char *) mergem); 664100966Siwasaki return 0; 665100966Siwasaki } 666100966Siwasaki 667100966Siwasaki abfd->tdata.sun_core_data = &mergem->suncoredata; 668100966Siwasaki abfd->tdata.sun_core_data->hdr = core; 669100966Siwasaki 670100966Siwasaki /* create the sections. This is raunchy, but bfd_close wants to reclaim 671114237Snjl them */ 672100966Siwasaki core_stacksec (abfd) = (asection *) bfd_zalloc (abfd, sizeof (asection)); 673100966Siwasaki if (core_stacksec (abfd) == NULL) 674100966Siwasaki { 675100966Siwasaki loser: 676100966Siwasaki bfd_release (abfd, (char *) mergem); 677100966Siwasaki return 0; 678100966Siwasaki } 679100966Siwasaki core_datasec (abfd) = (asection *) bfd_zalloc (abfd, sizeof (asection)); 680100966Siwasaki if (core_datasec (abfd) == NULL) 681100966Siwasaki { 682100966Siwasaki loser1: 683100966Siwasaki bfd_release (abfd, core_stacksec (abfd)); 684100966Siwasaki goto loser; 685100966Siwasaki } 686100966Siwasaki core_regsec (abfd) = (asection *) bfd_zalloc (abfd, sizeof (asection)); 687100966Siwasaki if (core_regsec (abfd) == NULL) 688100966Siwasaki { 689100966Siwasaki loser2: 690100966Siwasaki bfd_release (abfd, core_datasec (abfd)); 691100966Siwasaki goto loser1; 692100966Siwasaki } 693100966Siwasaki core_reg2sec (abfd) = (asection *) bfd_zalloc (abfd, sizeof (asection)); 694100966Siwasaki if (core_reg2sec (abfd) == NULL) 695100966Siwasaki { 696100966Siwasaki bfd_release (abfd, core_regsec (abfd)); 697100966Siwasaki goto loser2; 698100966Siwasaki } 699100966Siwasaki 700100966Siwasaki core_stacksec (abfd)->name = ".stack"; 701100966Siwasaki core_datasec (abfd)->name = ".data"; 702100966Siwasaki core_regsec (abfd)->name = ".reg"; 703100966Siwasaki core_reg2sec (abfd)->name = ".reg2"; 704100966Siwasaki 705100966Siwasaki core_stacksec (abfd)->flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS; 706100966Siwasaki core_datasec (abfd)->flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS; 707100966Siwasaki core_regsec (abfd)->flags = SEC_HAS_CONTENTS; 708100966Siwasaki core_reg2sec (abfd)->flags = SEC_HAS_CONTENTS; 709100966Siwasaki 710100966Siwasaki core_stacksec (abfd)->_raw_size = core->c_ssize; 711100966Siwasaki core_datasec (abfd)->_raw_size = core->c_dsize; 712100966Siwasaki core_regsec (abfd)->_raw_size = core->c_regs_size; 713100966Siwasaki core_reg2sec (abfd)->_raw_size = core->fp_stuff_size; 714100966Siwasaki 715100966Siwasaki core_stacksec (abfd)->vma = (core->c_stacktop - core->c_ssize); 716100966Siwasaki core_datasec (abfd)->vma = core->c_data_addr; 717100966Siwasaki core_regsec (abfd)->vma = 0; 718100966Siwasaki core_reg2sec (abfd)->vma = 0; 719100966Siwasaki 720100966Siwasaki core_stacksec (abfd)->filepos = core->c_len + core->c_dsize; 721100966Siwasaki core_datasec (abfd)->filepos = core->c_len; 722100966Siwasaki /* We'll access the regs afresh in the core file, like any section: */ 723100966Siwasaki core_regsec (abfd)->filepos = (file_ptr) core->c_regs_pos; 724100966Siwasaki core_reg2sec (abfd)->filepos = (file_ptr) core->fp_stuff_pos; 725114237Snjl 726107325Siwasaki /* Align to word at least */ 727107325Siwasaki core_stacksec (abfd)->alignment_power = 2; 728100966Siwasaki core_datasec (abfd)->alignment_power = 2; 729100966Siwasaki core_regsec (abfd)->alignment_power = 2; 730100966Siwasaki core_reg2sec (abfd)->alignment_power = 2; 731107325Siwasaki 732100966Siwasaki abfd->sections = core_stacksec (abfd); 733100966Siwasaki core_stacksec (abfd)->next = core_datasec (abfd); 734100966Siwasaki core_datasec (abfd)->next = core_regsec (abfd); 735100966Siwasaki core_regsec (abfd)->next = core_reg2sec (abfd); 736100966Siwasaki 737100966Siwasaki abfd->section_count = 4; 738100966Siwasaki 739100966Siwasaki return abfd->xvec; 740100966Siwasaki} 741100966Siwasaki 742100966Siwasakistatic char * 743100966Siwasakisunos4_core_file_failing_command (abfd) 744100966Siwasaki bfd *abfd; 745100966Siwasaki{ 746100966Siwasaki return core_hdr (abfd)->hdr->c_cmdname; 747100966Siwasaki} 748100966Siwasaki 749100966Siwasakistatic int 750100966Siwasakisunos4_core_file_failing_signal (abfd) 751100966Siwasaki bfd *abfd; 752100966Siwasaki{ 753100966Siwasaki return core_hdr (abfd)->hdr->c_signo; 754100966Siwasaki} 755100966Siwasaki 756100966Siwasakistatic boolean 757100966Siwasakisunos4_core_file_matches_executable_p (core_bfd, exec_bfd) 758100966Siwasaki bfd *core_bfd; 759100966Siwasaki bfd *exec_bfd; 760100966Siwasaki{ 761100966Siwasaki if (core_bfd->xvec != exec_bfd->xvec) 762100966Siwasaki { 763100966Siwasaki bfd_set_error (bfd_error_system_call); 764100966Siwasaki return false; 765100966Siwasaki } 766100966Siwasaki 767100966Siwasaki /* Solaris core files do not include an aouthdr. */ 768100966Siwasaki if ((core_hdr (core_bfd)->hdr)->c_len == SOLARIS_BCP_CORE_LEN) 769100966Siwasaki return true; 770100966Siwasaki 771100966Siwasaki return (memcmp ((char *) &((core_hdr (core_bfd)->hdr)->c_aouthdr), 772100966Siwasaki (char *) exec_hdr (exec_bfd), 773100966Siwasaki sizeof (struct internal_exec)) == 0) ? true : false; 774100966Siwasaki} 775100966Siwasaki 776100966Siwasaki#define MY_set_sizes sunos4_set_sizes 777100966Siwasakistatic boolean 778100966Siwasakisunos4_set_sizes (abfd) 779100966Siwasaki bfd *abfd; 780100966Siwasaki{ 781107325Siwasaki switch (bfd_get_arch (abfd)) 782107325Siwasaki { 783100966Siwasaki default: 784100966Siwasaki return false; 785100966Siwasaki case bfd_arch_sparc: 786107325Siwasaki adata (abfd).page_size = 0x2000; 787100966Siwasaki adata (abfd).segment_size = 0x2000; 788100966Siwasaki adata (abfd).exec_bytes_size = EXEC_BYTES_SIZE; 789100966Siwasaki return true; 790100966Siwasaki case bfd_arch_m68k: 791100966Siwasaki adata (abfd).page_size = 0x2000; 792100966Siwasaki adata (abfd).segment_size = 0x20000; 793100966Siwasaki adata (abfd).exec_bytes_size = EXEC_BYTES_SIZE; 794100966Siwasaki return true; 795100966Siwasaki } 796100966Siwasaki} 797100966Siwasaki 798100966Siwasaki/* We default to setting the toolversion field to 1, as is required by 799100966Siwasaki SunOS. */ 800100966Siwasaki#ifndef MY_exec_hdr_flags 801100966Siwasaki#define MY_exec_hdr_flags 1 802100966Siwasaki#endif 803100966Siwasaki 804100966Siwasaki#ifndef MY_entry_is_text_address 805100966Siwasaki#define MY_entry_is_text_address 0 806100966Siwasaki#endif 807100966Siwasaki#ifndef MY_add_dynamic_symbols 808100966Siwasaki#define MY_add_dynamic_symbols 0 809100966Siwasaki#endif 810100966Siwasaki#ifndef MY_add_one_symbol 811100966Siwasaki#define MY_add_one_symbol 0 812100966Siwasaki#endif 813100966Siwasaki#ifndef MY_link_dynamic_object 814100966Siwasaki#define MY_link_dynamic_object 0 815100966Siwasaki#endif 816100966Siwasaki#ifndef MY_write_dynamic_symbol 817100966Siwasaki#define MY_write_dynamic_symbol 0 818100966Siwasaki#endif 819100966Siwasaki#ifndef MY_check_dynamic_reloc 820100966Siwasaki#define MY_check_dynamic_reloc 0 821100966Siwasaki#endif 822100966Siwasaki#ifndef MY_finish_dynamic_link 823100966Siwasaki#define MY_finish_dynamic_link 0 824100966Siwasaki#endif 825100966Siwasaki 826100966Siwasakistatic CONST struct aout_backend_data sunos4_aout_backend = 827100966Siwasaki{ 828100966Siwasaki 0, /* zmagic files are not contiguous */ 829100966Siwasaki 1, /* text includes header */ 830100966Siwasaki MY_entry_is_text_address, 831100966Siwasaki MY_exec_hdr_flags, 832100966Siwasaki 0, /* default text vma */ 833100966Siwasaki sunos4_set_sizes, 834107325Siwasaki 0, /* header is counted in zmagic text */ 835107325Siwasaki MY_add_dynamic_symbols, 836107325Siwasaki MY_add_one_symbol, 837100966Siwasaki MY_link_dynamic_object, 838100966Siwasaki MY_write_dynamic_symbol, 839100966Siwasaki MY_check_dynamic_reloc, 840107325Siwasaki MY_finish_dynamic_link 841100966Siwasaki}; 842100966Siwasaki 843100966Siwasaki#define MY_core_file_failing_command sunos4_core_file_failing_command 844100966Siwasaki#define MY_core_file_failing_signal sunos4_core_file_failing_signal 845100966Siwasaki#define MY_core_file_matches_executable_p sunos4_core_file_matches_executable_p 846100966Siwasaki 847100966Siwasaki#define MY_bfd_debug_info_start bfd_void 848100966Siwasaki#define MY_bfd_debug_info_end bfd_void 849100966Siwasaki#define MY_bfd_debug_info_accumulate \ 850100966Siwasaki (void (*) PARAMS ((bfd *, struct sec *))) bfd_void 851100966Siwasaki#define MY_core_file_p sunos4_core_file_p 852100966Siwasaki#define MY_write_object_contents NAME(aout,sunos4_write_object_contents) 853100966Siwasaki#define MY_backend_data &sunos4_aout_backend 854100966Siwasaki 855100966Siwasaki#ifndef TARGET_IS_LITTLE_ENDIAN_P 856100966Siwasaki#define TARGET_IS_BIG_ENDIAN_P 857100966Siwasaki#endif 858100966Siwasaki 859100966Siwasaki#include "aout-target.h" 860100966Siwasaki