bfd/aoutf1.h

   1 /* A.out "format 1" file handling code for BFD.
   2    Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
   3    Written by Cygnus Support.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "libbfd.h"
  24
  25 #include "aout/sun4.h"
  26 #include "libaout.h"           /* BFD a.out internal data structures */
  27
  28 #include "aout/aout64.h"
  29 #include "aout/stab_gnu.h"
  30 #include "aout/ar.h"
  31
  32 /* This is needed to reject a NewsOS file, e.g. in
  33    gdb/testsuite/gdb.t10/crossload.exp. <kingdon@cygnus.com>
  34    I needed to add M_UNKNOWN to recognize a 68000 object, so this will
  35    probably no longer reject a NewsOS object.  <ian@cygnus.com>. */
  36 #define MACHTYPE_OK(mtype) ((mtype) == M_UNKNOWN \
  37                             || (mtype) == M_68010 \
  38                             || (mtype) == M_68020 \
  39                             || (mtype) == M_SPARC)
  40
  41 /*
  42 The file @code{aoutf1.h} contains the code for BFD's
  43 a.out back end. Control over the generated back end is given by these
  44 two preprocessor names:
  45 @table @code
  46 @item ARCH_SIZE
  47 This value should be either 32 or 64, depending upon the size of an
  48 int in the target format. It changes the sizes of the structs which
  49 perform the memory/disk mapping of structures.
  50
  51 The 64 bit backend may only be used if the host compiler supports 64
  52 ints (eg long long with gcc), by defining the name @code{HOST_64_BIT} in @code{bfd.h}.
  53 With this name defined, @emph{all} bfd operations are performed with 64bit
  54 arithmetic, not just those to a 64bit target.
  55
  56 @item TARGETNAME
  57 The name put into the target vector.
  58 @item
  59 @end table
  60
  61 */
  62
  63 /*SUPPRESS558*/
  64 /*SUPPRESS529*/
  65
  66 void
  67 DEFUN(NAME(sunos,set_arch_mach), (abfd, machtype),
  68       bfd *abfd AND int machtype)
  69 {
  70   /* Determine the architecture and machine type of the object file.  */
  71   enum bfd_architecture arch;
  72   long machine;
  73   switch (machtype) {
  74
  75   case M_UNKNOWN:
  76       /* Some Sun3s make magic numbers without cpu types in them, so
  77          we'll default to the 68000. */
  78     arch = bfd_arch_m68k;
  79     machine = 68000;
  80     break;
  81
  82   case M_68010:
  83   case M_HP200:
  84     arch = bfd_arch_m68k;
  85     machine = 68010;
  86     break;
  87
  88   case M_68020:
  89   case M_HP300:
  90     arch = bfd_arch_m68k;
  91     machine = 68020;
  92     break;
  93
  94   case M_SPARC:
  95     arch = bfd_arch_sparc;
  96     machine = 0;
  97     break;
  98
  99   case M_386:
 100   case M_386_DYNIX:
 101     arch = bfd_arch_i386;
 102     machine = 0;
 103     break;
 104
 105   case M_29K:
 106     arch = bfd_arch_a29k;
 107     machine = 0;
 108     break;
 109
 110   case M_HPUX:
 111     arch = bfd_arch_m68k;
 112     machine = 0;
 113     break;
 114
 115   default:
 116     arch = bfd_arch_obscure;
 117     machine = 0;
 118     break;
 119   }
 120   bfd_set_arch_mach(abfd, arch, machine);
 121 }
 122
 123 #define SET_ARCH_MACH(ABFD, EXEC) \
 124   NAME(sunos,set_arch_mach)(ABFD, N_MACHTYPE (EXEC)); \
 125   choose_reloc_size(ABFD);
 126
 127 /* Determine the size of a relocation entry, based on the architecture */
 128 static void
 129 DEFUN(choose_reloc_size,(abfd),
 130 bfd *abfd)
 131 {
 132   switch (bfd_get_arch(abfd)) {
 133   case bfd_arch_sparc:
 134   case bfd_arch_a29k:
 135     obj_reloc_entry_size (abfd) = RELOC_EXT_SIZE;
 136     break;
 137   default:
 138     obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
 139     break;
 140   }
 141 }
 142
 143 /* Write an object file in SunOS format.
 144   Section contents have already been written.  We write the
 145   file header, symbols, and relocation.  */
 146
 147 static boolean
 148 DEFUN(NAME(aout,sunos4_write_object_contents),
 149       (abfd),
 150       bfd *abfd)
 151 {
 152   struct external_exec exec_bytes;
 153   struct internal_exec *execp = exec_hdr (abfd);
 154
 155   /* Magic number, maestro, please!  */
 156   switch (bfd_get_arch(abfd)) {
 157   case bfd_arch_m68k:
 158     switch (bfd_get_mach(abfd)) {
 159     case 68010:
 160       N_SET_MACHTYPE(*execp, M_68010);
 161       break;
 162     default:
 163     case 68020:
 164       N_SET_MACHTYPE(*execp, M_68020);
 165       break;
 166     }
 167     break;
 168   case bfd_arch_sparc:
 169     N_SET_MACHTYPE(*execp, M_SPARC);
 170     break;
 171   case bfd_arch_i386:
 172     N_SET_MACHTYPE(*execp, M_386);
 173     break;
 174   case bfd_arch_a29k:
 175     N_SET_MACHTYPE(*execp, M_29K);
 176     break;
 177   default:
 178     N_SET_MACHTYPE(*execp, M_UNKNOWN);
 179   }
 180
 181   choose_reloc_size(abfd);
 182
 183 #if 0
 184   /* Some tools want this to be 0, some tools want this to be one.
 185      Today, it seems that 0 is the most important setting (PR1927) */
 186   N_SET_FLAGS (*execp, 0x0);
 187 #else
 188
 189   /* Fri Jun 11 14:23:31 PDT 1993
 190      FIXME
 191      Today's optimal setting is 1.  This is a pain, since it
 192      reopens 1927.  This should be readdressed by creating a new
 193      target for each each supported, giving perhaps sun3/m68k
 194      and sun4/sparc a.out formats.
 195      */
 196   N_SET_FLAGS (*execp, 1);
 197 #endif
 198
 199   WRITE_HEADERS(abfd, execp);
 200
 201   return true;
 202 }
 203 \f
 204 /* core files */
 205
 206 #define CORE_MAGIC 0x080456
 207 #define CORE_NAMELEN 16
 208
 209 /* The core structure is taken from the Sun documentation.
 210   Unfortunately, they don't document the FPA structure, or at least I
 211   can't find it easily.  Fortunately the core header contains its own
 212   length.  So this shouldn't cause problems, except for c_ucode, which
 213   so far we don't use but is easy to find with a little arithmetic. */
 214
 215 /* But the reg structure can be gotten from the SPARC processor handbook.
 216   This really should be in a GNU include file though so that gdb can use
 217   the same info. */
 218 struct regs {
 219   int r_psr;
 220   int r_pc;
 221   int r_npc;
 222   int r_y;
 223   int r_g1;
 224   int r_g2;
 225   int r_g3;
 226   int r_g4;
 227   int r_g5;
 228   int r_g6;
 229   int r_g7;
 230   int r_o0;
 231   int r_o1;
 232   int r_o2;
 233   int r_o3;
 234   int r_o4;
 235   int r_o5;
 236   int r_o6;
 237   int r_o7;
 238 };
 239
 240 /* Taken from Sun documentation: */
 241
 242 /* FIXME:  It's worse than we expect.  This struct contains TWO substructs
 243   neither of whose size we know, WITH STUFF IN BETWEEN THEM!  We can't
 244   even portably access the stuff in between!  */
 245
 246 struct external_sparc_core {
 247   int c_magic;                  /* Corefile magic number */
 248   int c_len;                    /* Sizeof (struct core) */
 249 #define SPARC_CORE_LEN  432
 250   int c_regs[19];               /* General purpose registers -- MACHDEP SIZE */
 251   struct external_exec c_aouthdr; /* A.out header */
 252   int c_signo;                    /* Killing signal, if any */
 253   int c_tsize;                    /* Text size (bytes) */
 254   int c_dsize;                    /* Data size (bytes) */
 255   int c_ssize;                    /* Stack size (bytes) */
 256   char c_cmdname[CORE_NAMELEN + 1]; /* Command name */
 257   double fp_stuff[1];               /* external FPU state (size unknown by us) */
 258   /* The type "double" is critical here, for alignment.
 259     SunOS declares a struct here, but the struct's alignment
 260       is double since it contains doubles.  */
 261   int c_ucode;                  /* Exception no. from u_code */
 262   /* (this member is not accessible by name since we don't
 263     portably know the size of fp_stuff.) */
 264 };
 265
 266 struct external_sun3_core {
 267   int c_magic;                  /* Corefile magic number */
 268   int c_len;                    /* Sizeof (struct core) */
 269 #define SUN3_CORE_LEN   826     /* As of SunOS 4.1.1 */
 270   int c_regs[18];               /* General purpose registers -- MACHDEP SIZE */
 271   struct external_exec c_aouthdr;       /* A.out header */
 272   int c_signo;                  /* Killing signal, if any */
 273   int c_tsize;                  /* Text size (bytes) */
 274   int c_dsize;                  /* Data size (bytes) */
 275   int c_ssize;                  /* Stack size (bytes) */
 276   char c_cmdname[CORE_NAMELEN + 1]; /* Command name */
 277   double fp_stuff[1];               /* external FPU state (size unknown by us) */
 278   /* The type "double" is critical here, for alignment.
 279     SunOS declares a struct here, but the struct's alignment
 280       is double since it contains doubles.  */
 281   int c_ucode;                  /* Exception no. from u_code */
 282   /* (this member is not accessible by name since we don't
 283     portably know the size of fp_stuff.) */
 284 };
 285
 286 struct internal_sunos_core {
 287   int c_magic;                  /* Corefile magic number */
 288   int c_len;                    /* Sizeof (struct core) */
 289   long c_regs_pos;              /* file offset of General purpose registers */
 290   int c_regs_size;              /* size of General purpose registers */
 291   struct internal_exec c_aouthdr; /* A.out header */
 292   int c_signo;                    /* Killing signal, if any */
 293   int c_tsize;                    /* Text size (bytes) */
 294   int c_dsize;                    /* Data size (bytes) */
 295   int c_ssize;                    /* Stack size (bytes) */
 296   bfd_vma c_stacktop;             /* Stack top (address) */
 297   char c_cmdname[CORE_NAMELEN + 1]; /* Command name */
 298   long fp_stuff_pos;            /* file offset of external FPU state (regs) */
 299   int fp_stuff_size;            /* Size of it */
 300   int c_ucode;                  /* Exception no. from u_code */
 301 };
 302
 303 /* byte-swap in the Sun-3 core structure */
 304 static void
 305 DEFUN(swapcore_sun3,(abfd, ext, intcore),
 306       bfd *abfd AND
 307       char *ext AND
 308       struct internal_sunos_core *intcore)
 309 {
 310   struct external_sun3_core *extcore = (struct external_sun3_core *)ext;
 311
 312   intcore->c_magic = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_magic);
 313   intcore->c_len   = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_len  );
 314   intcore->c_regs_pos  = (long) (((struct external_sun3_core *)0)->c_regs);
 315   intcore->c_regs_size = sizeof (extcore->c_regs);
 316   NAME(aout,swap_exec_header_in)(abfd, &extcore->c_aouthdr,&intcore->c_aouthdr);
 317   intcore->c_signo = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_signo);
 318   intcore->c_tsize = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_tsize);
 319   intcore->c_dsize = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_dsize);
 320   intcore->c_ssize = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_ssize);
 321   memcpy (intcore->c_cmdname, extcore->c_cmdname, sizeof (intcore->c_cmdname));
 322   intcore->fp_stuff_pos = (long) (((struct external_sun3_core *)0)->fp_stuff);
 323   /* FP stuff takes up whole rest of struct, except c_ucode. */
 324   intcore->fp_stuff_size = intcore->c_len - (sizeof extcore->c_ucode) -
 325     (file_ptr)(((struct external_sun3_core *)0)->fp_stuff);
 326   /* Ucode is the last thing in the struct -- just before the end */
 327   intcore->c_ucode =
 328     bfd_h_get_32 (abfd,
 329                   intcore->c_len - sizeof (extcore->c_ucode) + (unsigned char *)extcore);
 330   intcore->c_stacktop = 0x0E000000; /* By experimentation */
 331 }
 332
 333
 334 /* byte-swap in the Sparc core structure */
 335 static void
 336 DEFUN(swapcore_sparc,(abfd, ext, intcore),
 337       bfd *abfd AND
 338       char *ext AND
 339       struct internal_sunos_core *intcore)
 340 {
 341   struct external_sparc_core *extcore = (struct external_sparc_core *)ext;
 342
 343   intcore->c_magic = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_magic);
 344   intcore->c_len   = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_len  );
 345   intcore->c_regs_pos  = (long) (((struct external_sparc_core *)0)->c_regs);
 346   intcore->c_regs_size = sizeof (extcore->c_regs);
 347   NAME(aout,swap_exec_header_in)(abfd, &extcore->c_aouthdr,&intcore->c_aouthdr);
 348   intcore->c_signo = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_signo);
 349   intcore->c_tsize = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_tsize);
 350   intcore->c_dsize = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_dsize);
 351   intcore->c_ssize = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_ssize);
 352   memcpy (intcore->c_cmdname, extcore->c_cmdname, sizeof (intcore->c_cmdname));
 353   intcore->fp_stuff_pos = (long) (((struct external_sparc_core *)0)->fp_stuff);
 354   /* FP stuff takes up whole rest of struct, except c_ucode. */
 355   intcore->fp_stuff_size = intcore->c_len - (sizeof extcore->c_ucode) -
 356     (file_ptr)(((struct external_sparc_core *)0)->fp_stuff);
 357   /* Ucode is the last thing in the struct -- just before the end */
 358   intcore->c_ucode =
 359     bfd_h_get_32 (abfd,
 360                   intcore->c_len - sizeof (extcore->c_ucode) + (unsigned char *)extcore);
 361
 362   /* Supposedly the user stack grows downward from the bottom of kernel memory.
 363      Presuming that this remains true, this definition will work.  */
 364   /* Now sun has provided us with another challenge.  The value is different
 365      for sparc2 and sparc10 (both running SunOS 4.1.3).  We pick one or
 366      the other based on the current value of the stack pointer.  This
 367      loses (a) if the stack pointer has been clobbered, or (b) if the stack
 368      is larger than 128 megabytes.
 369
 370      It's times like these you're glad they're switching to ELF.
 371
 372      Note that using include files or nlist on /vmunix would be wrong,
 373      because we want the value for this core file, no matter what kind of
 374      machine we were compiled on or are running on.  */
 375 #define SPARC_USRSTACK_SPARC2 ((bfd_vma)0xf8000000)
 376 #define SPARC_USRSTACK_SPARC10 ((bfd_vma)0xf0000000)
 377   {
 378     bfd_vma sp = bfd_h_get_32
 379       (abfd, (unsigned char *)&((struct regs *)&extcore->c_regs[0])->r_o6);
 380     if (sp < SPARC_USRSTACK_SPARC10)
 381       intcore->c_stacktop = SPARC_USRSTACK_SPARC10;
 382     else
 383       intcore->c_stacktop = SPARC_USRSTACK_SPARC2;
 384   }
 385 }
 386
 387 /* need this cast because ptr is really void * */
 388 #define core_hdr(bfd) ((bfd)->tdata.sun_core_data)
 389 #define core_datasec(bfd) (core_hdr(bfd)->data_section)
 390 #define core_stacksec(bfd) (core_hdr(bfd)->stack_section)
 391 #define core_regsec(bfd) (core_hdr(bfd)->reg_section)
 392 #define core_reg2sec(bfd) (core_hdr(bfd)->reg2_section)
 393
 394 /* These are stored in the bfd's tdata */
 395 struct sun_core_struct {
 396   struct internal_sunos_core *hdr;             /* core file header */
 397   asection *data_section;
 398   asection *stack_section;
 399   asection *reg_section;
 400   asection *reg2_section;
 401 };
 402
 403 static bfd_target *
 404 DEFUN(sunos4_core_file_p,(abfd),
 405       bfd *abfd)
 406 {
 407   unsigned char longbuf[4];     /* Raw bytes of various header fields */
 408   int core_size;
 409   int core_mag;
 410   struct internal_sunos_core *core;
 411   char *extcore;
 412   struct mergem {
 413     struct sun_core_struct suncoredata;
 414     struct internal_sunos_core internal_sunos_core;
 415     char external_core[1];
 416   } *mergem;
 417
 418   if (bfd_read ((PTR)longbuf, 1, sizeof (longbuf), abfd) !=
 419       sizeof (longbuf))
 420     return 0;
 421   core_mag = bfd_h_get_32 (abfd, longbuf);
 422
 423   if (core_mag != CORE_MAGIC) return 0;
 424
 425   /* SunOS core headers can vary in length; second word is size; */
 426   if (bfd_read ((PTR)longbuf, 1, sizeof (longbuf), abfd) !=
 427       sizeof (longbuf))
 428     return 0;
 429   core_size = bfd_h_get_32 (abfd, longbuf);
 430   /* Sanity check */
 431   if (core_size > 20000)
 432     return 0;
 433
 434   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) < 0) return 0;
 435
 436   mergem = (struct mergem *)bfd_zalloc (abfd, core_size + sizeof (struct mergem));
 437   if (mergem == NULL) {
 438     bfd_error = no_memory;
 439     return 0;
 440   }
 441
 442   extcore = mergem->external_core;
 443
 444   if ((bfd_read ((PTR) extcore, 1, core_size, abfd)) != core_size) {
 445     bfd_error = system_call_error;
 446     bfd_release (abfd, (char *)mergem);
 447     return 0;
 448   }
 449
 450   /* Validate that it's a core file we know how to handle, due to sun
 451      botching the positioning of registers and other fields in a machine
 452      dependent way.  */
 453   core = &mergem->internal_sunos_core;
 454   switch (core_size) {
 455   case SPARC_CORE_LEN:
 456     swapcore_sparc (abfd, extcore, core);
 457     break;
 458   case SUN3_CORE_LEN:
 459     swapcore_sun3 (abfd, extcore, core);
 460     break;
 461   default:
 462     bfd_error = system_call_error;              /* FIXME */
 463     bfd_release (abfd, (char *)mergem);
 464     return 0;
 465   }
 466
 467  abfd->tdata.sun_core_data = &mergem->suncoredata;
 468  abfd->tdata.sun_core_data->hdr = core;
 469
 470   /* create the sections.  This is raunchy, but bfd_close wants to reclaim
 471      them */
 472   core_stacksec (abfd) = (asection *) bfd_zalloc (abfd, sizeof (asection));
 473   if (core_stacksec (abfd) == NULL) {
 474   loser:
 475     bfd_error = no_memory;
 476     bfd_release (abfd, (char *)mergem);
 477     return 0;
 478   }
 479   core_datasec (abfd) = (asection *) bfd_zalloc (abfd, sizeof (asection));
 480   if (core_datasec (abfd) == NULL) {
 481   loser1:
 482     bfd_release (abfd, core_stacksec (abfd));
 483     goto loser;
 484   }
 485   core_regsec (abfd) = (asection *) bfd_zalloc (abfd, sizeof (asection));
 486   if (core_regsec (abfd) == NULL) {
 487   loser2:
 488     bfd_release (abfd, core_datasec (abfd));
 489     goto loser1;
 490   }
 491   core_reg2sec (abfd) = (asection *) bfd_zalloc (abfd, sizeof (asection));
 492   if (core_reg2sec (abfd) == NULL) {
 493     bfd_release (abfd, core_regsec (abfd));
 494     goto loser2;
 495   }
 496
 497   core_stacksec (abfd)->name = ".stack";
 498   core_datasec (abfd)->name = ".data";
 499   core_regsec (abfd)->name = ".reg";
 500   core_reg2sec (abfd)->name = ".reg2";
 501
 502   core_stacksec (abfd)->flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
 503   core_datasec (abfd)->flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
 504   core_regsec (abfd)->flags = SEC_ALLOC + SEC_HAS_CONTENTS;
 505   core_reg2sec (abfd)->flags = SEC_ALLOC + SEC_HAS_CONTENTS;
 506
 507   core_stacksec (abfd)->_raw_size = core->c_ssize;
 508   core_datasec (abfd)->_raw_size = core->c_dsize;
 509   core_regsec (abfd)->_raw_size = core->c_regs_size;
 510   core_reg2sec (abfd)->_raw_size = core->fp_stuff_size;
 511
 512   core_stacksec (abfd)->vma = (core->c_stacktop - core->c_ssize);
 513   core_datasec (abfd)->vma = N_DATADDR(core->c_aouthdr);
 514   core_regsec (abfd)->vma = 0;
 515   core_reg2sec (abfd)->vma = 0;
 516
 517   core_stacksec (abfd)->filepos = core->c_len + core->c_dsize;
 518   core_datasec (abfd)->filepos = core->c_len;
 519   /* We'll access the regs afresh in the core file, like any section: */
 520   core_regsec (abfd)->filepos = (file_ptr)core->c_regs_pos;
 521   core_reg2sec (abfd)->filepos = (file_ptr)core->fp_stuff_pos;
 522
 523   /* Align to word at least */
 524   core_stacksec (abfd)->alignment_power = 2;
 525   core_datasec (abfd)->alignment_power = 2;
 526   core_regsec (abfd)->alignment_power = 2;
 527   core_reg2sec (abfd)->alignment_power = 2;
 528
 529   abfd->sections = core_stacksec (abfd);
 530   core_stacksec (abfd)->next = core_datasec (abfd);
 531   core_datasec (abfd)->next = core_regsec (abfd);
 532   core_regsec (abfd)->next = core_reg2sec (abfd);
 533
 534   abfd->section_count = 4;
 535
 536   return abfd->xvec;
 537 }
 538
 539 static char *sunos4_core_file_failing_command (abfd)
 540 bfd *abfd;
 541   {
 542   return core_hdr (abfd)->hdr->c_cmdname;
 543 }
 544
 545 static int
 546 DEFUN(sunos4_core_file_failing_signal,(abfd),
 547       bfd *abfd)
 548 {
 549   return core_hdr (abfd)->hdr->c_signo;
 550 }
 551
 552 static boolean
 553 DEFUN(sunos4_core_file_matches_executable_p, (core_bfd, exec_bfd),
 554       bfd *core_bfd AND
 555       bfd *exec_bfd)
 556 {
 557   if (core_bfd->xvec != exec_bfd->xvec) {
 558     bfd_error = system_call_error;
 559     return false;
 560   }
 561
 562   return (memcmp ((char *)&((core_hdr (core_bfd)->hdr)->c_aouthdr),
 563                   (char *) exec_hdr (exec_bfd),
 564                   sizeof (struct internal_exec)) == 0) ? true : false;
 565 }
 566
 567 #define MY_set_sizes sunos4_set_sizes
 568 static boolean
 569 DEFUN (sunos4_set_sizes, (abfd),
 570        bfd *abfd)
 571 {
 572   switch (bfd_get_arch (abfd))
 573     {
 574     default:
 575       return false;
 576     case bfd_arch_sparc:
 577       adata(abfd).page_size = 0x2000;
 578       adata(abfd).segment_size = 0x2000;
 579       adata(abfd).exec_bytes_size = EXEC_BYTES_SIZE;
 580       return true;
 581     case bfd_arch_m68k:
 582       adata(abfd).page_size = 0x2000;
 583       adata(abfd).segment_size = 0x20000;
 584       adata(abfd).exec_bytes_size = EXEC_BYTES_SIZE;
 585       return true;
 586     }
 587 }
 588
 589 static CONST struct aout_backend_data sunos4_aout_backend = {
 590   0, 1, 0, sunos4_set_sizes, 0,
 591 };
 592 \f
 593 #define MY_core_file_failing_command    sunos4_core_file_failing_command
 594 #define MY_core_file_failing_signal     sunos4_core_file_failing_signal
 595 #define MY_core_file_matches_executable_p sunos4_core_file_matches_executable_p
 596
 597 #define MY_bfd_debug_info_start         bfd_void
 598 #define MY_bfd_debug_info_end           bfd_void
 599 #define MY_bfd_debug_info_accumulate    \
 600                         (void (*) PARAMS ((bfd *, struct sec *))) bfd_void
 601 #define MY_core_file_p                  sunos4_core_file_p
 602 #define MY_write_object_contents        NAME(aout,sunos4_write_object_contents)
 603 #define MY_backend_data                 &sunos4_aout_backend
 604
 605 #define TARGET_IS_BIG_ENDIAN_P
 606
 607 #include "aout-target.h"