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, 2007 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 "sysdep.h" 24#include "bfd.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 flagword flags; 570 571 if (bfd_bread ((void *) longbuf, (bfd_size_type) sizeof (longbuf), abfd) 572 != sizeof (longbuf)) 573 return NULL; 574 core_mag = H_GET_32 (abfd, longbuf); 575 576 if (core_mag != CORE_MAGIC) 577 return NULL; 578 579 /* SunOS core headers can vary in length; second word is size; */ 580 if (bfd_bread ((void *) longbuf, (bfd_size_type) sizeof (longbuf), abfd) 581 != sizeof (longbuf)) 582 return NULL; 583 core_size = H_GET_32 (abfd, longbuf); 584 /* Sanity check. */ 585 if (core_size > 20000) 586 return NULL; 587 588 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 589 return NULL; 590 591 amt = core_size + sizeof (struct mergem); 592 mergem = bfd_zalloc (abfd, amt); 593 if (mergem == NULL) 594 return NULL; 595 596 extcore = mergem->external_core; 597 598 if ((bfd_bread ((void *) extcore, core_size, abfd)) != core_size) 599 { 600 loser: 601 bfd_release (abfd, (char *) mergem); 602 abfd->tdata.any = NULL; 603 bfd_section_list_clear (abfd); 604 return NULL; 605 } 606 607 /* Validate that it's a core file we know how to handle, due to sun 608 botching the positioning of registers and other fields in a machine 609 dependent way. */ 610 core = &mergem->internal_sunos_core; 611 switch (core_size) 612 { 613 case SPARC_CORE_LEN: 614 swapcore_sparc (abfd, extcore, core); 615 break; 616 case SUN3_CORE_LEN: 617 swapcore_sun3 (abfd, extcore, core); 618 break; 619 case SOLARIS_BCP_CORE_LEN: 620 swapcore_solaris_bcp (abfd, extcore, core); 621 break; 622 default: 623 bfd_set_error (bfd_error_system_call); /* FIXME. */ 624 goto loser; 625 } 626 627 abfd->tdata.sun_core_data = &mergem->suncoredata; 628 abfd->tdata.sun_core_data->hdr = core; 629 630 /* Create the sections. */ 631 flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS; 632 core_stacksec (abfd) = bfd_make_section_anyway_with_flags (abfd, ".stack", 633 flags); 634 if (core_stacksec (abfd) == NULL) 635 /* bfd_release frees everything allocated after it's arg. */ 636 goto loser; 637 638 flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS; 639 core_datasec (abfd) = bfd_make_section_anyway_with_flags (abfd, ".data", 640 flags); 641 if (core_datasec (abfd) == NULL) 642 goto loser; 643 644 flags = SEC_HAS_CONTENTS; 645 core_regsec (abfd) = bfd_make_section_anyway_with_flags (abfd, ".reg", 646 flags); 647 if (core_regsec (abfd) == NULL) 648 goto loser; 649 650 flags = SEC_HAS_CONTENTS; 651 core_reg2sec (abfd) = bfd_make_section_anyway_with_flags (abfd, ".reg2", 652 flags); 653 if (core_reg2sec (abfd) == NULL) 654 goto loser; 655 656 core_stacksec (abfd)->size = core->c_ssize; 657 core_datasec (abfd)->size = core->c_dsize; 658 core_regsec (abfd)->size = core->c_regs_size; 659 core_reg2sec (abfd)->size = core->fp_stuff_size; 660 661 core_stacksec (abfd)->vma = (core->c_stacktop - core->c_ssize); 662 core_datasec (abfd)->vma = core->c_data_addr; 663 core_regsec (abfd)->vma = 0; 664 core_reg2sec (abfd)->vma = 0; 665 666 core_stacksec (abfd)->filepos = core->c_len + core->c_dsize; 667 core_datasec (abfd)->filepos = core->c_len; 668 /* We'll access the regs afresh in the core file, like any section: */ 669 core_regsec (abfd)->filepos = (file_ptr) core->c_regs_pos; 670 core_reg2sec (abfd)->filepos = (file_ptr) core->fp_stuff_pos; 671 672 /* Align to word at least. */ 673 core_stacksec (abfd)->alignment_power = 2; 674 core_datasec (abfd)->alignment_power = 2; 675 core_regsec (abfd)->alignment_power = 2; 676 core_reg2sec (abfd)->alignment_power = 2; 677 678 return abfd->xvec; 679} 680 681static char * 682sunos4_core_file_failing_command (bfd *abfd) 683{ 684 return core_hdr (abfd)->hdr->c_cmdname; 685} 686 687static int 688sunos4_core_file_failing_signal (bfd *abfd) 689{ 690 return core_hdr (abfd)->hdr->c_signo; 691} 692 693static bfd_boolean 694sunos4_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd) 695{ 696 if (core_bfd->xvec != exec_bfd->xvec) 697 { 698 bfd_set_error (bfd_error_system_call); 699 return FALSE; 700 } 701 702 /* Solaris core files do not include an aouthdr. */ 703 if ((core_hdr (core_bfd)->hdr)->c_len == SOLARIS_BCP_CORE_LEN) 704 return TRUE; 705 706 return memcmp ((char *) &((core_hdr (core_bfd)->hdr)->c_aouthdr), 707 (char *) exec_hdr (exec_bfd), 708 sizeof (struct internal_exec)) == 0; 709} 710 711#define MY_set_sizes sunos4_set_sizes 712 713static bfd_boolean 714sunos4_set_sizes (bfd *abfd) 715{ 716 switch (bfd_get_arch (abfd)) 717 { 718 default: 719 return FALSE; 720 case bfd_arch_sparc: 721 adata (abfd).page_size = 0x2000; 722 adata (abfd).segment_size = 0x2000; 723 adata (abfd).exec_bytes_size = EXEC_BYTES_SIZE; 724 return TRUE; 725 case bfd_arch_m68k: 726 adata (abfd).page_size = 0x2000; 727 adata (abfd).segment_size = 0x20000; 728 adata (abfd).exec_bytes_size = EXEC_BYTES_SIZE; 729 return TRUE; 730 } 731} 732 733/* We default to setting the toolversion field to 1, as is required by 734 SunOS. */ 735#ifndef MY_exec_hdr_flags 736#define MY_exec_hdr_flags 1 737#endif 738 739#ifndef MY_entry_is_text_address 740#define MY_entry_is_text_address 0 741#endif 742#ifndef MY_add_dynamic_symbols 743#define MY_add_dynamic_symbols 0 744#endif 745#ifndef MY_add_one_symbol 746#define MY_add_one_symbol 0 747#endif 748#ifndef MY_link_dynamic_object 749#define MY_link_dynamic_object 0 750#endif 751#ifndef MY_write_dynamic_symbol 752#define MY_write_dynamic_symbol 0 753#endif 754#ifndef MY_check_dynamic_reloc 755#define MY_check_dynamic_reloc 0 756#endif 757#ifndef MY_finish_dynamic_link 758#define MY_finish_dynamic_link 0 759#endif 760 761static const struct aout_backend_data sunos4_aout_backend = 762{ 763 0, /* Zmagic files are not contiguous. */ 764 1, /* Text includes header. */ 765 MY_entry_is_text_address, 766 MY_exec_hdr_flags, 767 0, /* Default text vma. */ 768 sunos4_set_sizes, 769 0, /* Header is counted in zmagic text. */ 770 MY_add_dynamic_symbols, 771 MY_add_one_symbol, 772 MY_link_dynamic_object, 773 MY_write_dynamic_symbol, 774 MY_check_dynamic_reloc, 775 MY_finish_dynamic_link 776}; 777 778#define MY_core_file_failing_command sunos4_core_file_failing_command 779#define MY_core_file_failing_signal sunos4_core_file_failing_signal 780#define MY_core_file_matches_executable_p sunos4_core_file_matches_executable_p 781 782#define MY_bfd_debug_info_start bfd_void 783#define MY_bfd_debug_info_end bfd_void 784#define MY_bfd_debug_info_accumulate (void (*) (bfd *, struct bfd_section *)) bfd_void 785#define MY_core_file_p sunos4_core_file_p 786#define MY_write_object_contents NAME(aout, sunos4_write_object_contents) 787#define MY_backend_data & sunos4_aout_backend 788 789#ifndef TARGET_IS_LITTLE_ENDIAN_P 790#define TARGET_IS_BIG_ENDIAN_P 791#endif 792 793#include "aout-target.h" 794