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