bfd/aoutf1.h

   1 /* A.out "format 1" file handling code for BFD.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000
   3    Free Software Foundation, Inc.
   4    Written by Cygnus Support.
   5
   6 This file is part of BFD, the Binary File Descriptor library.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, 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 /*
  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 */
  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
  77 static boolean sunos_merge_private_bfd_data PARAMS ((bfd *, bfd *));
  78 static void sunos_set_arch_mach PARAMS ((bfd *, int));
  79 static void choose_reloc_size PARAMS ((bfd *));
  80 static boolean sunos_write_object_contents PARAMS ((bfd *));
  81 static const bfd_target *sunos4_core_file_p PARAMS ((bfd *));
  82 static char *sunos4_core_file_failing_command PARAMS ((bfd *));
  83 static int sunos4_core_file_failing_signal PARAMS ((bfd *));
  84 static boolean sunos4_core_file_matches_executable_p PARAMS ((bfd *, bfd *));
  85 static 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
  93 static boolean
  94 sunos_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
 113 static void
 114 sunos_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 */
 187 static void
 188 choose_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
 209 static boolean
 210 sunos_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, (long)(bfd_get_file_flags (abfd) & DYNAMIC));
 263
 264   WRITE_HEADERS (abfd, execp);
 265
 266   return true;
 267 }
 268 \f
 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.  */
 283 struct 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
 312 struct 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).  */
 335 struct 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
 369 struct 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
 390 struct 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
 409 static void swapcore_sun3
 410   PARAMS ((bfd *, char *, struct internal_sunos_core *));
 411 static void swapcore_sparc
 412   PARAMS ((bfd *, char *, struct internal_sunos_core *));
 413 static void swapcore_solaris_bcp
 414   PARAMS ((bfd *, char *, struct internal_sunos_core *));
 415
 416 /* byte-swap in the Sun-3 core structure */
 417 static void
 418 swapcore_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 */
 453 static void
 454 swapcore_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 */
 512 static void
 513 swapcore_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 */
 587 struct 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
 596 static const bfd_target *
 597 sunos4_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
 741 static char *
 742 sunos4_core_file_failing_command (abfd)
 743      bfd *abfd;
 744 {
 745   return core_hdr (abfd)->hdr->c_cmdname;
 746 }
 747
 748 static int
 749 sunos4_core_file_failing_signal (abfd)
 750      bfd *abfd;
 751 {
 752   return core_hdr (abfd)->hdr->c_signo;
 753 }
 754
 755 static boolean
 756 sunos4_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
 776 static boolean
 777 sunos4_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
 825 static 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 \f
 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"