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    2001, 2002, 2003, 2004, 2005
   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
  78 static bfd_boolean
  79 sunos_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
  97 static void
  98 sunos_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
 165 static void
 166 choose_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
 185 static bfd_boolean
 186 sunos_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 \f
 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.  */
 255 struct 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
 284 struct 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   int c_regs[19];                       /* 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).  */
 307 struct 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   int c_regs[19];                       /* 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
 341 struct 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
 362 struct 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
 383 static void
 384 swapcore_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 = (long) (((struct external_sun3_core *) 0)->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 = (long) (((struct external_sun3_core *) 0)->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     (file_ptr) (((struct external_sun3_core *) 0)->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
 418 static void
 419 swapcore_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 = (long) (((struct external_sparc_core *) 0)->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 = (long) (((struct external_sparc_core *) 0)->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     (file_ptr) (((struct external_sparc_core *) 0)->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, &((struct regs *) &extcore->c_regs[0])->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
 475 static void
 476 swapcore_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 = (long) (((struct external_solaris_bcp_core *) 0)->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     (long) (((struct external_solaris_bcp_core *) 0)->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     (file_ptr) (((struct external_solaris_bcp_core *) 0)->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, &((struct regs *) &extcore->c_regs[0])->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.  */
 546 struct 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
 555 static const bfd_target *
 556 sunos4_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
 677 static char *
 678 sunos4_core_file_failing_command (bfd *abfd)
 679 {
 680   return core_hdr (abfd)->hdr->c_cmdname;
 681 }
 682
 683 static int
 684 sunos4_core_file_failing_signal (bfd *abfd)
 685 {
 686   return core_hdr (abfd)->hdr->c_signo;
 687 }
 688
 689 static bfd_boolean
 690 sunos4_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
 709 static bfd_boolean
 710 sunos4_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
 757 static 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 \f
 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"