1/* A.out "format 1" file handling code for BFD. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 3 2001, 2002, 2003, 2004, 2005, 2006 4 Free Software Foundation, Inc. 5 Written by 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 2 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, MA 02110-1301, USA. */ 22 23#include "bfd.h" 24#include "sysdep.h" 25#include "libbfd.h" 26 27#include "aout/sun4.h" 28#include "libaout.h" /* BFD a.out internal data structures. */ 29 30#include "aout/aout64.h" 31#include "aout/stab_gnu.h" 32#include "aout/ar.h" 33 34/* This is needed to reject a NewsOS file, e.g. in 35 gdb/testsuite/gdb.t10/crossload.exp. <kingdon@cygnus.com> 36 I needed to add M_UNKNOWN to recognize a 68000 object, so this will 37 probably no longer reject a NewsOS object. <ian@cygnus.com>. */ 38#ifndef MACHTYPE_OK 39#define MACHTYPE_OK(mtype) \ 40 (((mtype) == M_SPARC && bfd_lookup_arch (bfd_arch_sparc, 0) != NULL) \ 41 || (((mtype) == M_UNKNOWN || (mtype) == M_68010 || (mtype) == M_68020) \ 42 && bfd_lookup_arch (bfd_arch_m68k, 0) != NULL)) 43#endif 44 45/* The file @code{aoutf1.h} contains the code for BFD's 46 a.out back end. Control over the generated back end is given by these 47 two preprocessor names: 48 @table @code 49 @item ARCH_SIZE 50 This value should be either 32 or 64, depending upon the size of an 51 int in the target format. It changes the sizes of the structs which 52 perform the memory/disk mapping of structures. 53 54 The 64 bit backend may only be used if the host compiler supports 64 55 ints (eg long long with gcc), by defining the name @code{BFD_HOST_64_BIT} in @code{bfd.h}. 56 With this name defined, @emph{all} bfd operations are performed with 64bit 57 arithmetic, not just those to a 64bit target. 58 59 @item TARGETNAME 60 The name put into the target vector. 61 @item 62 @end table. */ 63 64#if ARCH_SIZE == 64 65#define sunos_set_arch_mach sunos_64_set_arch_mach 66#define sunos_write_object_contents aout_64_sunos4_write_object_contents 67#else 68#define sunos_set_arch_mach sunos_32_set_arch_mach 69#define sunos_write_object_contents aout_32_sunos4_write_object_contents 70#endif 71 72/* Merge backend data into the output file. 73 This is necessary on sparclet-aout where we want the resultant machine 74 number to be M_SPARCLET if any input file is M_SPARCLET. */ 75 76#define MY_bfd_merge_private_bfd_data sunos_merge_private_bfd_data 77 78static bfd_boolean 79sunos_merge_private_bfd_data (bfd *ibfd, bfd *obfd) 80{ 81 if (bfd_get_flavour (ibfd) != bfd_target_aout_flavour 82 || bfd_get_flavour (obfd) != bfd_target_aout_flavour) 83 return TRUE; 84 85 if (bfd_get_arch (obfd) == bfd_arch_sparc) 86 { 87 if (bfd_get_mach (obfd) < bfd_get_mach (ibfd)) 88 bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd)); 89 } 90 91 return TRUE; 92} 93 94/* This is either sunos_32_set_arch_mach or sunos_64_set_arch_mach, 95 depending upon ARCH_SIZE. */ 96 97static void 98sunos_set_arch_mach (bfd *abfd, enum machine_type machtype) 99{ 100 /* Determine the architecture and machine type of the object file. */ 101 enum bfd_architecture arch; 102 unsigned long machine; 103 104 switch (machtype) 105 { 106 case M_UNKNOWN: 107 /* Some Sun3s make magic numbers without cpu types in them, so 108 we'll default to the 68000. */ 109 arch = bfd_arch_m68k; 110 machine = bfd_mach_m68000; 111 break; 112 113 case M_68010: 114 case M_HP200: 115 arch = bfd_arch_m68k; 116 machine = bfd_mach_m68010; 117 break; 118 119 case M_68020: 120 case M_HP300: 121 arch = bfd_arch_m68k; 122 machine = bfd_mach_m68020; 123 break; 124 125 case M_SPARC: 126 arch = bfd_arch_sparc; 127 machine = 0; 128 break; 129 130 case M_SPARCLET: 131 arch = bfd_arch_sparc; 132 machine = bfd_mach_sparc_sparclet; 133 break; 134 135 case M_SPARCLITE_LE: 136 arch = bfd_arch_sparc; 137 machine = bfd_mach_sparc_sparclite_le; 138 break; 139 140 case M_386: 141 case M_386_DYNIX: 142 arch = bfd_arch_i386; 143 machine = 0; 144 break; 145 146 case M_HPUX: 147 arch = bfd_arch_m68k; 148 machine = 0; 149 break; 150 151 default: 152 arch = bfd_arch_obscure; 153 machine = 0; 154 break; 155 } 156 bfd_set_arch_mach (abfd, arch, machine); 157} 158 159#define SET_ARCH_MACH(ABFD, EXEC) \ 160 NAME(sunos,set_arch_mach) (ABFD, N_MACHTYPE (EXEC)); \ 161 choose_reloc_size(ABFD); 162 163/* Determine the size of a relocation entry, based on the architecture. */ 164 165static void 166choose_reloc_size (bfd *abfd) 167{ 168 switch (bfd_get_arch (abfd)) 169 { 170 case bfd_arch_sparc: 171 obj_reloc_entry_size (abfd) = RELOC_EXT_SIZE; 172 break; 173 default: 174 obj_reloc_entry_size (abfd) = RELOC_STD_SIZE; 175 break; 176 } 177} 178 179/* Write an object file in SunOS format. Section contents have 180 already been written. We write the file header, symbols, and 181 relocation. The real name of this function is either 182 aout_64_sunos4_write_object_contents or 183 aout_32_sunos4_write_object_contents, depending upon ARCH_SIZE. */ 184 185static bfd_boolean 186sunos_write_object_contents (bfd *abfd) 187{ 188 struct external_exec exec_bytes; 189 struct internal_exec *execp = exec_hdr (abfd); 190 191 /* Magic number, maestro, please! */ 192 switch (bfd_get_arch (abfd)) 193 { 194 case bfd_arch_m68k: 195 switch (bfd_get_mach (abfd)) 196 { 197 case bfd_mach_m68000: 198 N_SET_MACHTYPE (*execp, M_UNKNOWN); 199 break; 200 case bfd_mach_m68010: 201 N_SET_MACHTYPE (*execp, M_68010); 202 break; 203 default: 204 case bfd_mach_m68020: 205 N_SET_MACHTYPE (*execp, M_68020); 206 break; 207 } 208 break; 209 case bfd_arch_sparc: 210 switch (bfd_get_mach (abfd)) 211 { 212 case bfd_mach_sparc_sparclet: 213 N_SET_MACHTYPE (*execp, M_SPARCLET); 214 break; 215 case bfd_mach_sparc_sparclite_le: 216 N_SET_MACHTYPE (*execp, M_SPARCLITE_LE); 217 break; 218 default: 219 N_SET_MACHTYPE (*execp, M_SPARC); 220 break; 221 } 222 break; 223 case bfd_arch_i386: 224 N_SET_MACHTYPE (*execp, M_386); 225 break; 226 default: 227 N_SET_MACHTYPE (*execp, M_UNKNOWN); 228 } 229 230 choose_reloc_size (abfd); 231 232 N_SET_FLAGS (*execp, aout_backend_info (abfd)->exec_hdr_flags); 233 234 N_SET_DYNAMIC (*execp, (long)(bfd_get_file_flags (abfd) & DYNAMIC)); 235 236 WRITE_HEADERS (abfd, execp); 237 238 return TRUE; 239} 240 241/* Core files. */ 242 243#define CORE_MAGIC 0x080456 244#define CORE_NAMELEN 16 245 246/* The core structure is taken from the Sun documentation. 247 Unfortunately, they don't document the FPA structure, or at least I 248 can't find it easily. Fortunately the core header contains its own 249 length. So this shouldn't cause problems, except for c_ucode, which 250 so far we don't use but is easy to find with a little arithmetic. */ 251 252/* But the reg structure can be gotten from the SPARC processor handbook. 253 This really should be in a GNU include file though so that gdb can use 254 the same info. */ 255struct regs 256{ 257 int r_psr; 258 int r_pc; 259 int r_npc; 260 int r_y; 261 int r_g1; 262 int r_g2; 263 int r_g3; 264 int r_g4; 265 int r_g5; 266 int r_g6; 267 int r_g7; 268 int r_o0; 269 int r_o1; 270 int r_o2; 271 int r_o3; 272 int r_o4; 273 int r_o5; 274 int r_o6; 275 int r_o7; 276}; 277 278/* Taken from Sun documentation: */ 279 280/* FIXME: It's worse than we expect. This struct contains TWO substructs 281 neither of whose size we know, WITH STUFF IN BETWEEN THEM! We can't 282 even portably access the stuff in between! */ 283 284struct external_sparc_core 285{ 286 int c_magic; /* Corefile magic number. */ 287 int c_len; /* Sizeof (struct core). */ 288#define SPARC_CORE_LEN 432 289 struct regs c_regs; /* General purpose registers -- MACHDEP SIZE. */ 290 struct external_exec c_aouthdr; /* A.out header. */ 291 int c_signo; /* Killing signal, if any. */ 292 int c_tsize; /* Text size (bytes). */ 293 int c_dsize; /* Data size (bytes). */ 294 int c_ssize; /* Stack size (bytes). */ 295 char c_cmdname[CORE_NAMELEN + 1]; /* Command name. */ 296 double fp_stuff[1]; /* External FPU state (size unknown by us). */ 297 /* The type "double" is critical here, for alignment. 298 SunOS declares a struct here, but the struct's 299 alignment is double since it contains doubles. */ 300 int c_ucode; /* Exception no. from u_code. */ 301 /* This member is not accessible by name since 302 we don't portably know the size of fp_stuff. */ 303}; 304 305/* Core files generated by the BCP (the part of Solaris which allows 306 it to run SunOS4 a.out files). */ 307struct external_solaris_bcp_core 308{ 309 int c_magic; /* Corefile magic number. */ 310 int c_len; /* Sizeof (struct core). */ 311#define SOLARIS_BCP_CORE_LEN 456 312 struct regs c_regs; /* General purpose registers -- MACHDEP SIZE. */ 313 int c_exdata_vp; /* Exdata structure. */ 314 int c_exdata_tsize; 315 int c_exdata_dsize; 316 int c_exdata_bsize; 317 int c_exdata_lsize; 318 int c_exdata_nshlibs; 319 short c_exdata_mach; 320 short c_exdata_mag; 321 int c_exdata_toffset; 322 int c_exdata_doffset; 323 int c_exdata_loffset; 324 int c_exdata_txtorg; 325 int c_exdata_datorg; 326 int c_exdata_entloc; 327 int c_signo; /* Killing signal, if any. */ 328 int c_tsize; /* Text size (bytes). */ 329 int c_dsize; /* Data size (bytes). */ 330 int c_ssize; /* Stack size (bytes). */ 331 char c_cmdname[CORE_NAMELEN + 1]; /* Command name. */ 332 double fp_stuff[1]; /* External FPU state (size unknown by us). */ 333 /* The type "double" is critical here, for alignment. 334 SunOS declares a struct here, but the struct's 335 alignment is double since it contains doubles. */ 336 int c_ucode; /* Exception no. from u_code. */ 337 /* This member is not accessible by name since 338 we don't portably know the size of fp_stuff. */ 339}; 340 341struct external_sun3_core 342{ 343 int c_magic; /* Corefile magic number. */ 344 int c_len; /* Sizeof (struct core). */ 345#define SUN3_CORE_LEN 826 /* As of SunOS 4.1.1. */ 346 int c_regs[18]; /* General purpose registers -- MACHDEP SIZE. */ 347 struct external_exec c_aouthdr; /* A.out header. */ 348 int c_signo; /* Killing signal, if any. */ 349 int c_tsize; /* Text size (bytes). */ 350 int c_dsize; /* Data size (bytes). */ 351 int c_ssize; /* Stack size (bytes). */ 352 char c_cmdname[CORE_NAMELEN + 1]; /* Command name. */ 353 double fp_stuff[1]; /* External FPU state (size unknown by us). */ 354 /* The type "double" is critical here, for alignment. 355 SunOS declares a struct here, but the struct's 356 alignment is double since it contains doubles. */ 357 int c_ucode; /* Exception no. from u_code. */ 358 /* This member is not accessible by name since 359 we don't portably know the size of fp_stuff. */ 360}; 361 362struct internal_sunos_core 363{ 364 int c_magic; /* Corefile magic number. */ 365 int c_len; /* Sizeof (struct core). */ 366 long c_regs_pos; /* File offset of General purpose registers. */ 367 int c_regs_size; /* Size of General purpose registers. */ 368 struct internal_exec c_aouthdr; /* A.out header. */ 369 int c_signo; /* Killing signal, if any. */ 370 int c_tsize; /* Text size (bytes). */ 371 int c_dsize; /* Data size (bytes). */ 372 bfd_vma c_data_addr; /* Data start (address). */ 373 int c_ssize; /* Stack size (bytes). */ 374 bfd_vma c_stacktop; /* Stack top (address). */ 375 char c_cmdname[CORE_NAMELEN + 1]; /* Command name. */ 376 long fp_stuff_pos; /* File offset of external FPU state (regs). */ 377 int fp_stuff_size; /* Size of it. */ 378 int c_ucode; /* Exception no. from u_code. */ 379}; 380 381/* Byte-swap in the Sun-3 core structure. */ 382 383static void 384swapcore_sun3 (bfd *abfd, char *ext, struct internal_sunos_core *intcore) 385{ 386 struct external_sun3_core *extcore = (struct external_sun3_core *) ext; 387 388 intcore->c_magic = H_GET_32 (abfd, &extcore->c_magic); 389 intcore->c_len = H_GET_32 (abfd, &extcore->c_len); 390 intcore->c_regs_pos = offsetof (struct external_sun3_core, c_regs); 391 intcore->c_regs_size = sizeof (extcore->c_regs); 392#if ARCH_SIZE == 64 393 aout_64_swap_exec_header_in 394#else 395 aout_32_swap_exec_header_in 396#endif 397 (abfd, &extcore->c_aouthdr, &intcore->c_aouthdr); 398 intcore->c_signo = H_GET_32 (abfd, &extcore->c_signo); 399 intcore->c_tsize = H_GET_32 (abfd, &extcore->c_tsize); 400 intcore->c_dsize = H_GET_32 (abfd, &extcore->c_dsize); 401 intcore->c_data_addr = N_DATADDR (intcore->c_aouthdr); 402 intcore->c_ssize = H_GET_32 (abfd, &extcore->c_ssize); 403 memcpy (intcore->c_cmdname, extcore->c_cmdname, sizeof (intcore->c_cmdname)); 404 intcore->fp_stuff_pos = offsetof (struct external_sun3_core, fp_stuff); 405 /* FP stuff takes up whole rest of struct, except c_ucode. */ 406 intcore->fp_stuff_size = intcore->c_len - (sizeof extcore->c_ucode) - 407 offsetof (struct external_sun3_core, fp_stuff); 408 /* Ucode is the last thing in the struct -- just before the end. */ 409 intcore->c_ucode = H_GET_32 (abfd, 410 (intcore->c_len 411 - sizeof (extcore->c_ucode) 412 + (unsigned char *) extcore)); 413 intcore->c_stacktop = 0x0E000000; /* By experimentation. */ 414} 415 416/* Byte-swap in the Sparc core structure. */ 417 418static void 419swapcore_sparc (bfd *abfd, char *ext, struct internal_sunos_core *intcore) 420{ 421 struct external_sparc_core *extcore = (struct external_sparc_core *) ext; 422 423 intcore->c_magic = H_GET_32 (abfd, &extcore->c_magic); 424 intcore->c_len = H_GET_32 (abfd, &extcore->c_len); 425 intcore->c_regs_pos = offsetof (struct external_sparc_core, c_regs); 426 intcore->c_regs_size = sizeof (extcore->c_regs); 427#if ARCH_SIZE == 64 428 aout_64_swap_exec_header_in 429#else 430 aout_32_swap_exec_header_in 431#endif 432 (abfd, &extcore->c_aouthdr, &intcore->c_aouthdr); 433 intcore->c_signo = H_GET_32 (abfd, &extcore->c_signo); 434 intcore->c_tsize = H_GET_32 (abfd, &extcore->c_tsize); 435 intcore->c_dsize = H_GET_32 (abfd, &extcore->c_dsize); 436 intcore->c_data_addr = N_DATADDR (intcore->c_aouthdr); 437 intcore->c_ssize = H_GET_32 (abfd, &extcore->c_ssize); 438 memcpy (intcore->c_cmdname, extcore->c_cmdname, sizeof (intcore->c_cmdname)); 439 intcore->fp_stuff_pos = offsetof (struct external_sparc_core, fp_stuff); 440 /* FP stuff takes up whole rest of struct, except c_ucode. */ 441 intcore->fp_stuff_size = intcore->c_len - (sizeof extcore->c_ucode) - 442 offsetof (struct external_sparc_core, fp_stuff); 443 /* Ucode is the last thing in the struct -- just before the end. */ 444 intcore->c_ucode = H_GET_32 (abfd, 445 (intcore->c_len 446 - sizeof (extcore->c_ucode) 447 + (unsigned char *) extcore)); 448 449 /* Supposedly the user stack grows downward from the bottom of kernel memory. 450 Presuming that this remains true, this definition will work. */ 451 /* Now sun has provided us with another challenge. The value is different 452 for sparc2 and sparc10 (both running SunOS 4.1.3). We pick one or 453 the other based on the current value of the stack pointer. This 454 loses (a) if the stack pointer has been clobbered, or (b) if the stack 455 is larger than 128 megabytes. 456 457 It's times like these you're glad they're switching to ELF. 458 459 Note that using include files or nlist on /vmunix would be wrong, 460 because we want the value for this core file, no matter what kind of 461 machine we were compiled on or are running on. */ 462#define SPARC_USRSTACK_SPARC2 ((bfd_vma)0xf8000000) 463#define SPARC_USRSTACK_SPARC10 ((bfd_vma)0xf0000000) 464 { 465 bfd_vma sp = H_GET_32 (abfd, &extcore->c_regs.r_o6); 466 if (sp < SPARC_USRSTACK_SPARC10) 467 intcore->c_stacktop = SPARC_USRSTACK_SPARC10; 468 else 469 intcore->c_stacktop = SPARC_USRSTACK_SPARC2; 470 } 471} 472 473/* Byte-swap in the Solaris BCP core structure. */ 474 475static void 476swapcore_solaris_bcp (bfd *abfd, char *ext, struct internal_sunos_core *intcore) 477{ 478 struct external_solaris_bcp_core *extcore = 479 (struct external_solaris_bcp_core *) ext; 480 481 intcore->c_magic = H_GET_32 (abfd, &extcore->c_magic); 482 intcore->c_len = H_GET_32 (abfd, &extcore->c_len); 483 intcore->c_regs_pos = offsetof (struct external_solaris_bcp_core, c_regs); 484 intcore->c_regs_size = sizeof (extcore->c_regs); 485 486 /* The Solaris BCP exdata structure does not contain an a_syms field, 487 so we are unable to synthesize an internal exec header. 488 Luckily we are able to figure out the start address of the data section, 489 which is the only thing needed from the internal exec header, 490 from the exdata structure. 491 492 As of Solaris 2.3, BCP core files for statically linked executables 493 are buggy. The exdata structure is not properly filled in, and 494 the data section is written from address zero instead of the data 495 start address. */ 496 memset ((void *) &intcore->c_aouthdr, 0, sizeof (struct internal_exec)); 497 intcore->c_data_addr = H_GET_32 (abfd, &extcore->c_exdata_datorg); 498 intcore->c_signo = H_GET_32 (abfd, &extcore->c_signo); 499 intcore->c_tsize = H_GET_32 (abfd, &extcore->c_tsize); 500 intcore->c_dsize = H_GET_32 (abfd, &extcore->c_dsize); 501 intcore->c_ssize = H_GET_32 (abfd, &extcore->c_ssize); 502 memcpy (intcore->c_cmdname, extcore->c_cmdname, sizeof (intcore->c_cmdname)); 503 intcore->fp_stuff_pos = 504 offsetof (struct external_solaris_bcp_core, fp_stuff); 505 /* FP stuff takes up whole rest of struct, except c_ucode. */ 506 intcore->fp_stuff_size = intcore->c_len - (sizeof extcore->c_ucode) - 507 offsetof (struct external_solaris_bcp_core, fp_stuff); 508 /* Ucode is the last thing in the struct -- just before the end */ 509 intcore->c_ucode = H_GET_32 (abfd, 510 (intcore->c_len 511 - sizeof (extcore->c_ucode) 512 + (unsigned char *) extcore)); 513 514 /* Supposedly the user stack grows downward from the bottom of kernel memory. 515 Presuming that this remains true, this definition will work. */ 516 /* Now sun has provided us with another challenge. The value is different 517 for sparc2 and sparc10 (both running SunOS 4.1.3). We pick one or 518 the other based on the current value of the stack pointer. This 519 loses (a) if the stack pointer has been clobbered, or (b) if the stack 520 is larger than 128 megabytes. 521 522 It's times like these you're glad they're switching to ELF. 523 524 Note that using include files or nlist on /vmunix would be wrong, 525 because we want the value for this core file, no matter what kind of 526 machine we were compiled on or are running on. */ 527#define SPARC_USRSTACK_SPARC2 ((bfd_vma)0xf8000000) 528#define SPARC_USRSTACK_SPARC10 ((bfd_vma)0xf0000000) 529 { 530 bfd_vma sp = H_GET_32 (abfd, &extcore->c_regs.r_o6); 531 if (sp < SPARC_USRSTACK_SPARC10) 532 intcore->c_stacktop = SPARC_USRSTACK_SPARC10; 533 else 534 intcore->c_stacktop = SPARC_USRSTACK_SPARC2; 535 } 536} 537 538/* Need this cast because ptr is really void *. */ 539#define core_hdr(bfd) ((bfd)->tdata.sun_core_data) 540#define core_datasec(bfd) (core_hdr (bfd)->data_section) 541#define core_stacksec(bfd) (core_hdr (bfd)->stack_section) 542#define core_regsec(bfd) (core_hdr (bfd)->reg_section) 543#define core_reg2sec(bfd) (core_hdr (bfd)->reg2_section) 544 545/* These are stored in the bfd's tdata. */ 546struct sun_core_struct 547{ 548 struct internal_sunos_core *hdr; /* Core file header. */ 549 asection *data_section; 550 asection *stack_section; 551 asection *reg_section; 552 asection *reg2_section; 553}; 554 555static const bfd_target * 556sunos4_core_file_p (bfd *abfd) 557{ 558 unsigned char longbuf[4]; /* Raw bytes of various header fields. */ 559 bfd_size_type core_size, amt; 560 unsigned long core_mag; 561 struct internal_sunos_core *core; 562 char *extcore; 563 struct mergem 564 { 565 struct sun_core_struct suncoredata; 566 struct internal_sunos_core internal_sunos_core; 567 char external_core[1]; 568 } *mergem; 569 570 if (bfd_bread ((void *) longbuf, (bfd_size_type) sizeof (longbuf), abfd) 571 != sizeof (longbuf)) 572 return NULL; 573 core_mag = H_GET_32 (abfd, longbuf); 574 575 if (core_mag != CORE_MAGIC) 576 return NULL; 577 578 /* SunOS core headers can vary in length; second word is size; */ 579 if (bfd_bread ((void *) longbuf, (bfd_size_type) sizeof (longbuf), abfd) 580 != sizeof (longbuf)) 581 return NULL; 582 core_size = H_GET_32 (abfd, longbuf); 583 /* Sanity check. */ 584 if (core_size > 20000) 585 return NULL; 586 587 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 588 return NULL; 589 590 amt = core_size + sizeof (struct mergem); 591 mergem = bfd_zalloc (abfd, amt); 592 if (mergem == NULL) 593 return NULL; 594 595 extcore = mergem->external_core; 596 597 if ((bfd_bread ((void *) extcore, core_size, abfd)) != core_size) 598 { 599 loser: 600 bfd_release (abfd, (char *) mergem); 601 abfd->tdata.any = NULL; 602 bfd_section_list_clear (abfd); 603 return NULL; 604 } 605 606 /* Validate that it's a core file we know how to handle, due to sun 607 botching the positioning of registers and other fields in a machine 608 dependent way. */ 609 core = &mergem->internal_sunos_core; 610 switch (core_size) 611 { 612 case SPARC_CORE_LEN: 613 swapcore_sparc (abfd, extcore, core); 614 break; 615 case SUN3_CORE_LEN: 616 swapcore_sun3 (abfd, extcore, core); 617 break; 618 case SOLARIS_BCP_CORE_LEN: 619 swapcore_solaris_bcp (abfd, extcore, core); 620 break; 621 default: 622 bfd_set_error (bfd_error_system_call); /* FIXME. */ 623 goto loser; 624 } 625 626 abfd->tdata.sun_core_data = &mergem->suncoredata; 627 abfd->tdata.sun_core_data->hdr = core; 628 629 /* Create the sections. */ 630 core_stacksec (abfd) = bfd_make_section_anyway (abfd, ".stack"); 631 if (core_stacksec (abfd) == NULL) 632 /* bfd_release frees everything allocated after it's arg. */ 633 goto loser; 634 635 core_datasec (abfd) = bfd_make_section_anyway (abfd, ".data"); 636 if (core_datasec (abfd) == NULL) 637 goto loser; 638 639 core_regsec (abfd) = bfd_make_section_anyway (abfd, ".reg"); 640 if (core_regsec (abfd) == NULL) 641 goto loser; 642 643 core_reg2sec (abfd) = bfd_make_section_anyway (abfd, ".reg2"); 644 if (core_reg2sec (abfd) == NULL) 645 goto loser; 646 647 core_stacksec (abfd)->flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS; 648 core_datasec (abfd)->flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS; 649 core_regsec (abfd)->flags = SEC_HAS_CONTENTS; 650 core_reg2sec (abfd)->flags = SEC_HAS_CONTENTS; 651 652 core_stacksec (abfd)->size = core->c_ssize; 653 core_datasec (abfd)->size = core->c_dsize; 654 core_regsec (abfd)->size = core->c_regs_size; 655 core_reg2sec (abfd)->size = core->fp_stuff_size; 656 657 core_stacksec (abfd)->vma = (core->c_stacktop - core->c_ssize); 658 core_datasec (abfd)->vma = core->c_data_addr; 659 core_regsec (abfd)->vma = 0; 660 core_reg2sec (abfd)->vma = 0; 661 662 core_stacksec (abfd)->filepos = core->c_len + core->c_dsize; 663 core_datasec (abfd)->filepos = core->c_len; 664 /* We'll access the regs afresh in the core file, like any section: */ 665 core_regsec (abfd)->filepos = (file_ptr) core->c_regs_pos; 666 core_reg2sec (abfd)->filepos = (file_ptr) core->fp_stuff_pos; 667 668 /* Align to word at least. */ 669 core_stacksec (abfd)->alignment_power = 2; 670 core_datasec (abfd)->alignment_power = 2; 671 core_regsec (abfd)->alignment_power = 2; 672 core_reg2sec (abfd)->alignment_power = 2; 673 674 return abfd->xvec; 675} 676 677static char * 678sunos4_core_file_failing_command (bfd *abfd) 679{ 680 return core_hdr (abfd)->hdr->c_cmdname; 681} 682 683static int 684sunos4_core_file_failing_signal (bfd *abfd) 685{ 686 return core_hdr (abfd)->hdr->c_signo; 687} 688 689static bfd_boolean 690sunos4_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd) 691{ 692 if (core_bfd->xvec != exec_bfd->xvec) 693 { 694 bfd_set_error (bfd_error_system_call); 695 return FALSE; 696 } 697 698 /* Solaris core files do not include an aouthdr. */ 699 if ((core_hdr (core_bfd)->hdr)->c_len == SOLARIS_BCP_CORE_LEN) 700 return TRUE; 701 702 return memcmp ((char *) &((core_hdr (core_bfd)->hdr)->c_aouthdr), 703 (char *) exec_hdr (exec_bfd), 704 sizeof (struct internal_exec)) == 0; 705} 706 707#define MY_set_sizes sunos4_set_sizes 708 709static bfd_boolean 710sunos4_set_sizes (bfd *abfd) 711{ 712 switch (bfd_get_arch (abfd)) 713 { 714 default: 715 return FALSE; 716 case bfd_arch_sparc: 717 adata (abfd).page_size = 0x2000; 718 adata (abfd).segment_size = 0x2000; 719 adata (abfd).exec_bytes_size = EXEC_BYTES_SIZE; 720 return TRUE; 721 case bfd_arch_m68k: 722 adata (abfd).page_size = 0x2000; 723 adata (abfd).segment_size = 0x20000; 724 adata (abfd).exec_bytes_size = EXEC_BYTES_SIZE; 725 return TRUE; 726 } 727} 728 729/* We default to setting the toolversion field to 1, as is required by 730 SunOS. */ 731#ifndef MY_exec_hdr_flags 732#define MY_exec_hdr_flags 1 733#endif 734 735#ifndef MY_entry_is_text_address 736#define MY_entry_is_text_address 0 737#endif 738#ifndef MY_add_dynamic_symbols 739#define MY_add_dynamic_symbols 0 740#endif 741#ifndef MY_add_one_symbol 742#define MY_add_one_symbol 0 743#endif 744#ifndef MY_link_dynamic_object 745#define MY_link_dynamic_object 0 746#endif 747#ifndef MY_write_dynamic_symbol 748#define MY_write_dynamic_symbol 0 749#endif 750#ifndef MY_check_dynamic_reloc 751#define MY_check_dynamic_reloc 0 752#endif 753#ifndef MY_finish_dynamic_link 754#define MY_finish_dynamic_link 0 755#endif 756 757static const struct aout_backend_data sunos4_aout_backend = 758{ 759 0, /* Zmagic files are not contiguous. */ 760 1, /* Text includes header. */ 761 MY_entry_is_text_address, 762 MY_exec_hdr_flags, 763 0, /* Default text vma. */ 764 sunos4_set_sizes, 765 0, /* Header is counted in zmagic text. */ 766 MY_add_dynamic_symbols, 767 MY_add_one_symbol, 768 MY_link_dynamic_object, 769 MY_write_dynamic_symbol, 770 MY_check_dynamic_reloc, 771 MY_finish_dynamic_link 772}; 773 774#define MY_core_file_failing_command sunos4_core_file_failing_command 775#define MY_core_file_failing_signal sunos4_core_file_failing_signal 776#define MY_core_file_matches_executable_p sunos4_core_file_matches_executable_p 777 778#define MY_bfd_debug_info_start bfd_void 779#define MY_bfd_debug_info_end bfd_void 780#define MY_bfd_debug_info_accumulate (void (*) (bfd *, struct bfd_section *)) bfd_void 781#define MY_core_file_p sunos4_core_file_p 782#define MY_write_object_contents NAME(aout, sunos4_write_object_contents) 783#define MY_backend_data & sunos4_aout_backend 784 785#ifndef TARGET_IS_LITTLE_ENDIAN_P 786#define TARGET_IS_BIG_ENDIAN_P 787#endif 788 789#include "aout-target.h" 790