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