bfd/aoutf1.h

   1 /* A.out "format 1" file handling code
   2    Copyright (C) 1990-1991 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 <ansidecl.h>
  22 #include <sysdep.h>
  23 #include <a.out.sun4.h>
  24 #include "bfd.h"
  25 #include "libaout.h"
  26 #include "libbfd.h"
  27
  28 #include "aout64.h"
  29 #include "stab.gnu.h"
  30 #include "ar.h"
  31
  32 /*
  33 The file @code{aoutf1.h} contains the code for BFD's
  34 a.out back end. Control over the generated back end is given by these
  35 two preprocessor names:
  36 @table @code
  37 @item ARCH_SIZE
  38 This value should be either 32 or 64, depending upon the size of an
  39 int in the target format. It changes the sizes of the structs which
  40 perform the memory/disk mapping of structures.
  41
  42 The 64 bit backend may only be used if the host compiler supports 64
  43 ints (eg long long with gcc), by defining the name @code{HOST_64_BIT} in @code{bfd.h}.
  44 With this name defined, @emph{all} bfd operations are performed with 64bit
  45 arithmetic, not just those to a 64bit target.
  46
  47 @item TARGETNAME
  48 The name put into the target vector.
  49 @item
  50 @end table
  51
  52 */
  53
  54 void (*bfd_error_trap)();
  55
  56 static bfd_target *sunos4_callback ();
  57
  58 /*SUPPRESS558*/
  59 /*SUPPRESS529*/
  60
  61 bfd_target *
  62 DEFUN(NAME(sunos,object_p), (abfd),
  63      bfd *abfd)
  64 {
  65   unsigned char magicbuf[4];    /* Raw bytes of magic number from file */
  66   unsigned long magic;          /* Swapped magic number */
  67
  68   bfd_error = system_call_error;
  69
  70   if (bfd_read ((PTR)magicbuf, 1 , 4, abfd) !=
  71       sizeof (magicbuf))
  72     return 0;
  73   magic = bfd_h_get_32 (abfd, magicbuf);
  74
  75   if (N_BADMAG (*((struct internal_exec *) &magic))) return 0;
  76
  77   return NAME(aout,some_aout_object_p) (abfd, sunos4_callback);
  78 }
  79
  80   /* Determine the size of a relocation entry, based on the architecture */
  81 static void
  82 DEFUN(choose_reloc_size,(abfd),
  83 bfd *abfd)
  84 {
  85   switch (bfd_get_arch(abfd)) {
  86   case bfd_arch_sparc:
  87   case bfd_arch_a29k:
  88     obj_reloc_entry_size (abfd) = RELOC_EXT_SIZE;
  89     break;
  90   default:
  91     obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
  92     break;
  93   }
  94 }
  95
  96 /* Set parameters about this a.out file that are machine-dependent.
  97    This routine is called from some_aout_object_p just before it returns.  */
  98
  99 static bfd_target *
 100 sunos4_callback (abfd)
 101      bfd *abfd;
 102 {
 103   struct internal_exec *execp = exec_hdr (abfd);
 104   enum bfd_architecture arch;
 105   long machine;
 106   WORK_OUT_FILE_POSITIONS(abfd, execp);
 107
 108   /* Determine the architecture and machine type of the object file.  */
 109   switch (N_MACHTYPE (*exec_hdr (abfd))) {
 110
 111   case M_UNKNOWN:
 112     arch = bfd_arch_unknown;
 113     machine = 0;
 114     break;
 115
 116   case M_68010:
 117     arch = bfd_arch_m68k;
 118     machine = 68010;
 119     break;
 120
 121   case M_68020:
 122     arch = bfd_arch_m68k;
 123     machine = 68020;
 124     break;
 125
 126   case M_SPARC:
 127     arch = bfd_arch_sparc;
 128     machine = 0;
 129     break;
 130
 131   case M_386:
 132     arch = bfd_arch_i386;
 133     machine = 0;
 134     break;
 135
 136   case M_29K:
 137     arch = bfd_arch_a29k;
 138     machine = 0;
 139     break;
 140
 141   default:
 142     arch = bfd_arch_obscure;
 143     machine = 0;
 144     break;
 145   }
 146   bfd_set_arch_mach(abfd, arch, machine);
 147   choose_reloc_size(abfd);
 148   return abfd->xvec;
 149 }
 150
 151
 152 /* Write an object file in SunOS format.
 153   Section contents have already been written.  We write the
 154   file header, symbols, and relocation.  */
 155
 156 boolean
 157 DEFUN(NAME(aout,sunos4_write_object_contents),
 158       (abfd),
 159       bfd *abfd)
 160 {
 161   bfd_size_type data_pad = 0;
 162   struct external_exec exec_bytes;
 163   struct internal_exec *execp = exec_hdr (abfd);
 164
 165   execp->a_text = obj_textsec (abfd)->size;
 166
 167   /* Magic number, maestro, please!  */
 168   switch (bfd_get_arch(abfd)) {
 169   case bfd_arch_m68k:
 170     switch (bfd_get_mach(abfd)) {
 171     case 68010:
 172       N_SET_MACHTYPE(*execp, M_68010);
 173       break;
 174     default:
 175     case 68020:
 176       N_SET_MACHTYPE(*execp, M_68020);
 177       break;
 178     }
 179     break;
 180   case bfd_arch_sparc:
 181     N_SET_MACHTYPE(*execp, M_SPARC);
 182     break;
 183   case bfd_arch_i386:
 184     N_SET_MACHTYPE(*execp, M_386);
 185     break;
 186   case bfd_arch_a29k:
 187     N_SET_MACHTYPE(*execp, M_29K);
 188     break;
 189   default:
 190     N_SET_MACHTYPE(*execp, M_UNKNOWN);
 191   }
 192
 193   choose_reloc_size(abfd);
 194
 195   /* FIXME */
 196   N_SET_FLAGS (*execp, 0x1);
 197
 198   WRITE_HEADERS(abfd, execp);
 199
 200   return true;
 201 }
 202 \f
 203 /* core files */
 204
 205 #define CORE_MAGIC 0x080456
 206 #define CORE_NAMELEN 16
 207
 208 /* The core structure is taken from the Sun documentation.
 209   Unfortunately, they don't document the FPA structure, or at least I
 210   can't find it easily.  Fortunately the core header contains its own
 211   length.  So this shouldn't cause problems, except for c_ucode, which
 212   so far we don't use but is easy to find with a little arithmetic. */
 213
 214 /* But the reg structure can be gotten from the SPARC processor handbook.
 215   This really should be in a GNU include file though so that gdb can use
 216   the same info. */
 217 struct regs {
 218   int r_psr;
 219   int r_pc;
 220   int r_npc;
 221   int r_y;
 222   int r_g1;
 223   int r_g2;
 224   int r_g3;
 225   int r_g4;
 226   int r_g5;
 227   int r_g6;
 228   int r_g7;
 229   int r_o0;
 230   int r_o1;
 231   int r_o2;
 232   int r_o3;
 233   int r_o4;
 234   int r_o5;
 235   int r_o6;
 236   int r_o7;
 237 };
 238
 239 /* Taken from Sun documentation: */
 240
 241 /* FIXME:  It's worse than we expect.  This struct contains TWO substructs
 242   neither of whose size we know, WITH STUFF IN BETWEEN THEM!  We can't
 243   even portably access the stuff in between!  */
 244
 245 struct external_sparc_core {
 246   int c_magic;                  /* Corefile magic number */
 247   int c_len;                    /* Sizeof (struct core) */
 248 #define SPARC_CORE_LEN  432
 249   int c_regs[19];               /* General purpose registers -- MACHDEP SIZE */
 250   struct external_exec c_aouthdr; /* A.out header */
 251   int c_signo;                    /* Killing signal, if any */
 252   int c_tsize;                    /* Text size (bytes) */
 253   int c_dsize;                    /* Data size (bytes) */
 254   int c_ssize;                    /* Stack size (bytes) */
 255   char c_cmdname[CORE_NAMELEN + 1]; /* Command name */
 256   double fp_stuff[1];               /* external FPU state (size unknown by us) */
 257   /* The type "double" is critical here, for alignment.
 258     SunOS declares a struct here, but the struct's alignment
 259       is double since it contains doubles.  */
 260   int c_ucode;                  /* Exception no. from u_code */
 261   /* (this member is not accessible by name since we don't
 262     portably know the size of fp_stuff.) */
 263 };
 264
 265 struct external_sun3_core {
 266   int c_magic;                  /* Corefile magic number */
 267   int c_len;                    /* Sizeof (struct core) */
 268 #define SUN3_CORE_LEN   826     /* As of SunOS 4.1.1 */
 269   int c_regs[18];               /* General purpose registers -- MACHDEP SIZE */
 270   struct external_exec c_aouthdr;       /* A.out header */
 271   int c_signo;                  /* Killing signal, if any */
 272   int c_tsize;                  /* Text size (bytes) */
 273   int c_dsize;                  /* Data size (bytes) */
 274   int c_ssize;                  /* Stack size (bytes) */
 275   char c_cmdname[CORE_NAMELEN + 1]; /* Command name */
 276   double fp_stuff[1];               /* external FPU state (size unknown by us) */
 277   /* The type "double" is critical here, for alignment.
 278     SunOS declares a struct here, but the struct's alignment
 279       is double since it contains doubles.  */
 280   int c_ucode;                  /* Exception no. from u_code */
 281   /* (this member is not accessible by name since we don't
 282     portably know the size of fp_stuff.) */
 283 };
 284
 285 struct internal_sunos_core {
 286   int c_magic;                  /* Corefile magic number */
 287   int c_len;                    /* Sizeof (struct core) */
 288   long c_regs_pos;              /* file offset of General purpose registers */
 289   int c_regs_size;              /* size of General purpose registers */
 290   struct internal_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   long c_stacktop;                /* Stack top (address) */
 296   char c_cmdname[CORE_NAMELEN + 1]; /* Command name */
 297   long fp_stuff_pos;            /* file offset of external FPU state (regs) */
 298   int fp_stuff_size;            /* Size of it */
 299   int c_ucode;                  /* Exception no. from u_code */
 300 };
 301
 302 /* byte-swap in the Sun-3 core structure */
 303 static void
 304 DEFUN(swapcore_sun3,(abfd, ext, intcore),
 305       bfd *abfd AND
 306       char *ext AND
 307       struct internal_sunos_core *intcore)
 308 {
 309   struct external_sun3_core *extcore = (struct external_sun3_core *)ext;
 310
 311   intcore->c_magic = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_magic);
 312   intcore->c_len   = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_len  );
 313   intcore->c_regs_pos  = (long) (((struct external_sun3_core *)0)->c_regs);
 314   intcore->c_regs_size = sizeof (extcore->c_regs);
 315   NAME(aout,swap_exec_header_in)(abfd, &extcore->c_aouthdr,&intcore->c_aouthdr);
 316   intcore->c_signo = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_signo);
 317   intcore->c_tsize = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_tsize);
 318   intcore->c_dsize = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_dsize);
 319   intcore->c_ssize = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_ssize);
 320   bcopy (extcore->c_cmdname, intcore->c_cmdname, sizeof (intcore->c_cmdname));
 321   intcore->fp_stuff_pos = (long) (((struct external_sun3_core *)0)->fp_stuff);
 322   /* FP stuff takes up whole rest of struct, except c_ucode. */
 323   intcore->fp_stuff_size = intcore->c_len - (sizeof extcore->c_ucode) -
 324     (file_ptr)(((struct external_sun3_core *)0)->fp_stuff);
 325   /* Ucode is the last thing in the struct -- just before the end */
 326   intcore->c_ucode =
 327     bfd_h_get_32 (abfd,
 328                   intcore->c_len - sizeof (extcore->c_ucode) + (unsigned char *)extcore);
 329   intcore->c_stacktop = 0x0E000000; /* By experimentation */
 330 }
 331
 332
 333 /* byte-swap in the Sparc core structure */
 334 static void
 335 DEFUN(swapcore_sparc,(abfd, ext, intcore),
 336       bfd *abfd AND
 337       char *ext AND
 338       struct internal_sunos_core *intcore)
 339 {
 340   struct external_sparc_core *extcore = (struct external_sparc_core *)ext;
 341
 342   intcore->c_magic = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_magic);
 343   intcore->c_len   = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_len  );
 344   intcore->c_regs_pos  = (long) (((struct external_sparc_core *)0)->c_regs);
 345   intcore->c_regs_size = sizeof (extcore->c_regs);
 346   NAME(aout,swap_exec_header_in)(abfd, &extcore->c_aouthdr,&intcore->c_aouthdr);
 347   intcore->c_signo = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_signo);
 348   intcore->c_tsize = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_tsize);
 349   intcore->c_dsize = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_dsize);
 350   intcore->c_ssize = bfd_h_get_32 (abfd, (unsigned char *)&extcore->c_ssize);
 351   bcopy (extcore->c_cmdname, intcore->c_cmdname, sizeof (intcore->c_cmdname));
 352   intcore->fp_stuff_pos = (long) (((struct external_sparc_core *)0)->fp_stuff);
 353   /* FP stuff takes up whole rest of struct, except c_ucode. */
 354   intcore->fp_stuff_size = intcore->c_len - (sizeof extcore->c_ucode) -
 355     (file_ptr)(((struct external_sparc_core *)0)->fp_stuff);
 356   /* Ucode is the last thing in the struct -- just before the end */
 357   intcore->c_ucode =
 358     bfd_h_get_32 (abfd,
 359                   intcore->c_len - sizeof (extcore->c_ucode) + (unsigned char *)extcore);
 360   /* Supposedly the user stack grows downward from the bottom of kernel memory.
 361      Presuming that this remains true, this definition will work. */
 362 #define SPARC_USRSTACK (-(128*1024*1024))
 363   intcore->c_stacktop = SPARC_USRSTACK; /* By experimentation */
 364 }
 365
 366 /* need this cast because ptr is really void * */
 367 #define core_hdr(bfd) (((struct suncoredata *) (bfd->tdata))->hdr)
 368 #define core_datasec(bfd) (((struct suncoredata *) ((bfd)->tdata))->data_section)
 369 #define core_stacksec(bfd) (((struct suncoredata*)((bfd)->tdata))->stack_section)
 370 #define core_regsec(bfd) (((struct suncoredata *) ((bfd)->tdata))->reg_section)
 371 #define core_reg2sec(bfd) (((struct suncoredata *) ((bfd)->tdata))->reg2_section)
 372
 373 /* These are stored in the bfd's tdata */
 374 struct suncoredata {
 375   struct internal_sunos_core *hdr;             /* core file header */
 376   asection *data_section;
 377   asection *stack_section;
 378   asection *reg_section;
 379   asection *reg2_section;
 380 };
 381
 382 static bfd_target *
 383 DEFUN(sunos4_core_file_p,(abfd),
 384       bfd *abfd)
 385 {
 386   unsigned char longbuf[4];     /* Raw bytes of various header fields */
 387   int core_size;
 388   int core_mag;
 389   struct internal_sunos_core *core;
 390   char *extcore;
 391   struct mergem {
 392     struct suncoredata suncoredata;
 393     struct internal_sunos_core internal_sunos_core;
 394     char external_core[1];
 395   } *mergem;
 396
 397   bfd_error = system_call_error;
 398
 399   if (bfd_read ((PTR)longbuf, 1, sizeof (longbuf), abfd) !=
 400       sizeof (longbuf))
 401     return 0;
 402   core_mag = bfd_h_get_32 (abfd, longbuf);
 403
 404   if (core_mag != CORE_MAGIC) return 0;
 405
 406   /* SunOS core headers can vary in length; second word is size; */
 407   if (bfd_read ((PTR)longbuf, 1, sizeof (longbuf), abfd) !=
 408       sizeof (longbuf))
 409     return 0;
 410   core_size = bfd_h_get_32 (abfd, longbuf);
 411   /* Sanity check */
 412   if (core_size > 20000)
 413     return 0;
 414
 415   if (bfd_seek (abfd, 0L, false) < 0) return 0;
 416
 417   mergem = (struct mergem *)bfd_zalloc (abfd, core_size + sizeof (struct mergem));
 418   if (mergem == NULL) {
 419     bfd_error = no_memory;
 420     return 0;
 421   }
 422
 423   extcore = mergem->external_core;
 424
 425   if ((bfd_read ((PTR) extcore, 1, core_size, abfd)) != core_size) {
 426     bfd_error = system_call_error;
 427     bfd_release (abfd, (char *)mergem);
 428     return 0;
 429   }
 430
 431   /* Validate that it's a core file we know how to handle, due to sun
 432      botching the positioning of registers and other fields in a machine
 433      dependent way.  */
 434   core = &mergem->internal_sunos_core;
 435   switch (core_size) {
 436   case SPARC_CORE_LEN:
 437     swapcore_sparc (abfd, extcore, core);
 438     break;
 439   case SUN3_CORE_LEN:
 440     swapcore_sun3 (abfd, extcore, core);
 441     break;
 442   default:
 443     bfd_error = system_call_error;              /* FIXME */
 444     bfd_release (abfd, (char *)mergem);
 445     return 0;
 446   }
 447
 448   set_tdata (abfd, &mergem->suncoredata);
 449   core_hdr (abfd) = core;
 450
 451   /* create the sections.  This is raunchy, but bfd_close wants to reclaim
 452      them */
 453   core_stacksec (abfd) = (asection *) bfd_zalloc (abfd, sizeof (asection));
 454   if (core_stacksec (abfd) == NULL) {
 455   loser:
 456     bfd_error = no_memory;
 457     bfd_release (abfd, (char *)mergem);
 458     return 0;
 459   }
 460   core_datasec (abfd) = (asection *) bfd_zalloc (abfd, sizeof (asection));
 461   if (core_datasec (abfd) == NULL) {
 462   loser1:
 463     bfd_release (abfd, core_stacksec (abfd));
 464     goto loser;
 465   }
 466   core_regsec (abfd) = (asection *) bfd_zalloc (abfd, sizeof (asection));
 467   if (core_regsec (abfd) == NULL) {
 468   loser2:
 469     bfd_release (abfd, core_datasec (abfd));
 470     goto loser1;
 471   }
 472   core_reg2sec (abfd) = (asection *) bfd_zalloc (abfd, sizeof (asection));
 473   if (core_reg2sec (abfd) == NULL) {
 474     bfd_release (abfd, core_regsec (abfd));
 475     goto loser2;
 476   }
 477
 478   core_stacksec (abfd)->name = ".stack";
 479   core_datasec (abfd)->name = ".data";
 480   core_regsec (abfd)->name = ".reg";
 481   core_reg2sec (abfd)->name = ".reg2";
 482
 483   core_stacksec (abfd)->flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
 484   core_datasec (abfd)->flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
 485   core_regsec (abfd)->flags = SEC_ALLOC + SEC_HAS_CONTENTS;
 486   core_reg2sec (abfd)->flags = SEC_ALLOC + SEC_HAS_CONTENTS;
 487
 488   core_stacksec (abfd)->size = core->c_ssize;
 489   core_datasec (abfd)->size = core->c_dsize;
 490   core_regsec (abfd)->size = core->c_regs_size;
 491   core_reg2sec (abfd)->size = core->fp_stuff_size;
 492
 493   core_stacksec (abfd)->vma = (core->c_stacktop - core->c_ssize);
 494   core_datasec (abfd)->vma = N_DATADDR(core->c_aouthdr);
 495   core_regsec (abfd)->vma = -1;
 496   core_reg2sec (abfd)->vma = -1;
 497
 498   core_stacksec (abfd)->filepos = core->c_len + core->c_dsize;
 499   core_datasec (abfd)->filepos = core->c_len;
 500   /* We'll access the regs afresh in the core file, like any section: */
 501   core_regsec (abfd)->filepos = (file_ptr)core->c_regs_pos;
 502   core_reg2sec (abfd)->filepos = (file_ptr)core->fp_stuff_pos;
 503
 504   /* Align to word at least */
 505   core_stacksec (abfd)->alignment_power = 2;
 506   core_datasec (abfd)->alignment_power = 2;
 507   core_regsec (abfd)->alignment_power = 2;
 508   core_reg2sec (abfd)->alignment_power = 2;
 509
 510   abfd->sections = core_stacksec (abfd);
 511   core_stacksec (abfd)->next = core_datasec (abfd);
 512   core_datasec (abfd)->next = core_regsec (abfd);
 513   core_regsec (abfd)->next = core_reg2sec (abfd);
 514
 515   abfd->section_count = 4;
 516
 517   return abfd->xvec;
 518 }
 519
 520 static char *sunos4_core_file_failing_command (abfd)
 521 bfd *abfd;
 522   {
 523   return core_hdr (abfd)->c_cmdname;
 524 }
 525
 526 static int
 527 DEFUN(sunos4_core_file_failing_signal,(abfd),
 528       bfd *abfd)
 529 {
 530   return core_hdr (abfd)->c_signo;
 531 }
 532
 533 static boolean
 534 DEFUN(sunos4_core_file_matches_executable_p, (core_bfd, exec_bfd),
 535       bfd *core_bfd AND
 536       bfd *exec_bfd)
 537 {
 538   if (core_bfd->xvec != exec_bfd->xvec) {
 539     bfd_error = system_call_error;
 540     return false;
 541   }
 542
 543   return (bcmp ((char *)&core_hdr (core_bfd)->c_aouthdr,
 544                 (char *) exec_hdr (exec_bfd),
 545                 sizeof (struct internal_exec)) == 0) ? true : false;
 546 }
 547 \f
 548 /* We use BFD generic archive files.  */
 549 #define aout_32_openr_next_archived_file        bfd_generic_openr_next_archived_file
 550 #define aout_32_generic_stat_arch_elt           bfd_generic_stat_arch_elt
 551 #define aout_32_slurp_armap                     bfd_slurp_bsd_armap
 552 #define aout_32_slurp_extended_name_table       bfd_true
 553 #define aout_32_write_armap                     bsd_write_armap
 554 #define aout_32_truncate_arname                 bfd_bsd_truncate_arname
 555 #define aout_32_machine_type                    sunos_machine_type
 556
 557 #define aout_32_core_file_failing_command       sunos4_core_file_failing_command
 558 #define aout_32_core_file_failing_signal        sunos4_core_file_failing_signal
 559 #define aout_32_core_file_matches_executable_p  sunos4_core_file_matches_executable_p
 560
 561
 562 #define aout_64_openr_next_archived_file        bfd_generic_openr_next_archived_file
 563 #define aout_64_generic_stat_arch_elt           bfd_generic_stat_arch_elt
 564 #define aout_64_slurp_armap                     bfd_slurp_bsd_armap
 565 #define aout_64_slurp_extended_name_table       bfd_true
 566 #define aout_64_write_armap                     bsd_write_armap
 567 #define aout_64_truncate_arname                 bfd_bsd_truncate_arname
 568 #define aout_64_machine_type                    sunos_machine_type
 569
 570 #define aout_64_core_file_failing_command       sunos4_core_file_failing_command
 571 #define aout_64_core_file_failing_signal        sunos4_core_file_failing_signal
 572 #define aout_64_core_file_matches_executable_p  sunos4_core_file_matches_executable_p
 573
 574 #define aout_64_bfd_debug_info_start            bfd_void
 575 #define aout_64_bfd_debug_info_end              bfd_void
 576 #define aout_64_bfd_debug_info_accumulate       bfd_void
 577
 578 #define aout_32_bfd_debug_info_start            bfd_void
 579 #define aout_32_bfd_debug_info_end              bfd_void
 580 #define aout_32_bfd_debug_info_accumulate       (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
 581
 582
 583
 584 /* We implement these routines ourselves, rather than using the generic
 585 a.out versions.  */
 586 #define aout_write_object_contents      sunos4_write_object_contents
 587
 588 bfd_target VECNAME =
 589   {
 590     TARGETNAME,
 591     bfd_target_aout_flavour,
 592     true,                       /* target byte order */
 593     true,                       /* target headers byte order */
 594     (HAS_RELOC | EXEC_P |       /* object flags */
 595      HAS_LINENO | HAS_DEBUG |
 596      HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
 597     (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
 598     ' ',                                                   /* ar_pad_char */
 599     16,                                                    /* ar_max_namelen */
 600     3,                                                     /* minimum alignment power */
 601     _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* data */
 602     _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs */
 603
 604       {_bfd_dummy_target, NAME(sunos,object_p),
 605        bfd_generic_archive_p, sunos4_core_file_p},
 606       {bfd_false, NAME(aout,mkobject),
 607        _bfd_generic_mkarchive, bfd_false},
 608       {bfd_false, NAME(aout,sunos4_write_object_contents), /* bfd_write_contents */
 609        _bfd_write_archive_contents, bfd_false},
 610
 611     JUMP_TABLE(JNAME(aout))
 612     };