bfd/aout-adobe.c

   1 /* BFD back-end for a.out.adobe binaries.
   2    Copyright 1990, 91, 92, 93, 94, 95, 96, 98, 1999
   3    Free Software Foundation, Inc.
   4    Written by Cygnus Support.  Based on bout.c.
   5
   6 This file is part of BFD, the Binary File Descriptor library.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include "bfd.h"
  23 #include "sysdep.h"
  24 #include "libbfd.h"
  25
  26 #include "aout/adobe.h"
  27
  28 #include "aout/stab_gnu.h"
  29 #include "libaout.h"            /* BFD a.out internal data structures */
  30
  31 extern const bfd_target a_out_adobe_vec;                /* Forward decl */
  32
  33 static const bfd_target *aout_adobe_callback PARAMS ((bfd *));
  34
  35 extern boolean aout_32_slurp_symbol_table PARAMS ((bfd *abfd));
  36 extern boolean aout_32_write_syms PARAMS ((bfd *));
  37 static void aout_adobe_write_section PARAMS ((bfd *abfd, sec_ptr sect));
  38
  39 /* Swaps the information in an executable header taken from a raw byte
  40    stream memory image, into the internal exec_header structure.  */
  41
  42 void aout_adobe_swap_exec_header_in
  43   PARAMS ((bfd *abfd, struct external_exec *raw_bytes,
  44            struct internal_exec *execp));
  45
  46 void
  47 aout_adobe_swap_exec_header_in (abfd, raw_bytes, execp)
  48      bfd *abfd;
  49      struct external_exec *raw_bytes;
  50      struct internal_exec *execp;
  51 {
  52   struct external_exec *bytes = (struct external_exec *)raw_bytes;
  53
  54   /* Now fill in fields in the execp, from the bytes in the raw data.  */
  55   execp->a_info   = bfd_h_get_32 (abfd, bytes->e_info);
  56   execp->a_text   = GET_WORD (abfd, bytes->e_text);
  57   execp->a_data   = GET_WORD (abfd, bytes->e_data);
  58   execp->a_bss    = GET_WORD (abfd, bytes->e_bss);
  59   execp->a_syms   = GET_WORD (abfd, bytes->e_syms);
  60   execp->a_entry  = GET_WORD (abfd, bytes->e_entry);
  61   execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
  62   execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
  63 }
  64
  65 /* Swaps the information in an internal exec header structure into the
  66    supplied buffer ready for writing to disk.  */
  67
  68 PROTO(void, aout_adobe_swap_exec_header_out,
  69           (bfd *abfd,
  70            struct internal_exec *execp,
  71            struct external_exec *raw_bytes));
  72 void
  73 aout_adobe_swap_exec_header_out (abfd, execp, raw_bytes)
  74      bfd *abfd;
  75      struct internal_exec *execp;
  76      struct external_exec *raw_bytes;
  77 {
  78   struct external_exec *bytes = (struct external_exec *)raw_bytes;
  79
  80   /* Now fill in fields in the raw data, from the fields in the exec struct. */
  81   bfd_h_put_32 (abfd, execp->a_info  , bytes->e_info);
  82   PUT_WORD (abfd, execp->a_text  , bytes->e_text);
  83   PUT_WORD (abfd, execp->a_data  , bytes->e_data);
  84   PUT_WORD (abfd, execp->a_bss   , bytes->e_bss);
  85   PUT_WORD (abfd, execp->a_syms  , bytes->e_syms);
  86   PUT_WORD (abfd, execp->a_entry , bytes->e_entry);
  87   PUT_WORD (abfd, execp->a_trsize, bytes->e_trsize);
  88   PUT_WORD (abfd, execp->a_drsize, bytes->e_drsize);
  89 }
  90
  91
  92 static const bfd_target *
  93 aout_adobe_object_p (abfd)
  94      bfd *abfd;
  95 {
  96   struct internal_exec anexec;
  97   struct external_exec exec_bytes;
  98   char *targ;
  99
 100   if (bfd_read ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd)
 101       != EXEC_BYTES_SIZE) {
 102     if (bfd_get_error () != bfd_error_system_call)
 103       bfd_set_error (bfd_error_wrong_format);
 104     return 0;
 105   }
 106
 107   anexec.a_info = bfd_h_get_32 (abfd, exec_bytes.e_info);
 108
 109   /* Normally we just compare for the magic number.
 110      However, a bunch of Adobe tools aren't fixed up yet; they generate
 111      files using ZMAGIC(!).
 112      If the environment variable GNUTARGET is set to "a.out.adobe", we will
 113      take just about any a.out file as an Adobe a.out file.  FIXME!  */
 114
 115   if (N_BADMAG (anexec)) {
 116     targ = getenv ("GNUTARGET");
 117     if (targ && !strcmp (targ, a_out_adobe_vec.name))
 118       ;         /* Just continue anyway, if specifically set to this format */
 119     else
 120       {
 121         bfd_set_error (bfd_error_wrong_format);
 122         return 0;
 123       }
 124   }
 125
 126   aout_adobe_swap_exec_header_in (abfd, &exec_bytes, &anexec);
 127   return aout_32_some_aout_object_p (abfd, &anexec, aout_adobe_callback);
 128 }
 129
 130
 131 /* Finish up the opening of a b.out file for reading.  Fill in all the
 132    fields that are not handled by common code.  */
 133
 134 static const bfd_target *
 135 aout_adobe_callback (abfd)
 136      bfd *abfd;
 137 {
 138   struct internal_exec *execp = exec_hdr (abfd);
 139   asection *sect;
 140   struct external_segdesc ext[1];
 141   char *section_name;
 142   char try_again[30];   /* name and number */
 143   char *newname;
 144   int trynum;
 145   flagword flags;
 146
 147   /* Architecture and machine type -- unknown in this format.  */
 148   bfd_set_arch_mach(abfd, bfd_arch_unknown, 0);
 149
 150   /* The positions of the string table and symbol table.  */
 151   obj_str_filepos (abfd) = N_STROFF (*execp);
 152   obj_sym_filepos (abfd) = N_SYMOFF (*execp);
 153
 154   /* Suck up the section information from the file, one section at a time.  */
 155
 156   for (;;) {
 157     if (bfd_read ((PTR) ext, 1, sizeof (*ext), abfd) != sizeof (*ext)) {
 158       if (bfd_get_error () != bfd_error_system_call)
 159         bfd_set_error (bfd_error_wrong_format);
 160       return 0;
 161     }
 162     switch (ext->e_type[0]) {
 163     case N_TEXT:
 164       section_name = ".text";
 165       flags = SEC_CODE | SEC_LOAD | SEC_ALLOC | SEC_HAS_CONTENTS;
 166       break;
 167
 168     case N_DATA:
 169       section_name = ".data";
 170       flags = SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_HAS_CONTENTS;
 171       break;
 172
 173     case N_BSS:
 174       section_name = ".bss";
 175       flags = SEC_DATA | SEC_HAS_CONTENTS;
 176       break;
 177
 178     case 0:
 179       goto no_more_sections;
 180
 181     default:
 182       (*_bfd_error_handler)
 183         (_("%s: Unknown section type in a.out.adobe file: %x\n"),
 184          bfd_get_filename (abfd), ext->e_type[0]);
 185       goto no_more_sections;
 186     }
 187
 188     /* First one is called ".text" or whatever; subsequent ones are
 189        ".text1", ".text2", ... */
 190
 191     bfd_set_error (bfd_error_no_error);
 192     sect = bfd_make_section (abfd, section_name);
 193     trynum = 0;
 194     while (!sect) {
 195       if (bfd_get_error () != bfd_error_no_error)
 196         return 0;       /* Some other error -- slide into the sunset */
 197       sprintf (try_again, "%s%d", section_name, ++trynum);
 198       sect = bfd_make_section (abfd, try_again);
 199     }
 200
 201     /* Fix the name, if it is a sprintf'd name.  */
 202     if (sect->name == try_again) {
 203       newname = (char *) bfd_zalloc(abfd, strlen (sect->name));
 204       if (newname == NULL)
 205         return 0;
 206       strcpy (newname, sect->name);
 207       sect->name = newname;
 208     }
 209
 210     /* Now set the section's attributes.  */
 211     bfd_set_section_flags (abfd, sect, flags);
 212     sect->_raw_size = ((ext->e_size[0] << 8)    /* Assumed big-endian */
 213                       | ext->e_size[1] << 8)
 214                       | ext->e_size[2];
 215     sect->_cooked_size = sect->_raw_size;
 216     sect->vma = bfd_h_get_32 (abfd, ext->e_virtbase);
 217     sect->filepos = bfd_h_get_32 (abfd, ext->e_filebase);
 218     /* FIXME XXX alignment? */
 219
 220     /* Set relocation information for first section of each type.  */
 221     if (trynum == 0) switch (ext->e_type[0]) {
 222     case N_TEXT:
 223       sect->rel_filepos = N_TRELOFF (*execp);
 224       sect->reloc_count = execp->a_trsize;
 225       break;
 226
 227     case N_DATA:
 228       sect->rel_filepos = N_DRELOFF (*execp);
 229       sect->reloc_count = execp->a_drsize;
 230       break;
 231     }
 232   }
 233 no_more_sections:
 234
 235   adata(abfd).reloc_entry_size = sizeof (struct reloc_std_external);
 236   adata(abfd).symbol_entry_size = sizeof (struct external_nlist);
 237   adata(abfd).page_size = 1; /* Not applicable. */
 238   adata(abfd).segment_size = 1; /* Not applicable. */
 239   adata(abfd).exec_bytes_size = EXEC_BYTES_SIZE;
 240
 241   return abfd->xvec;
 242 }
 243
 244 struct bout_data_struct {
 245     struct aoutdata a;
 246     struct internal_exec e;
 247 };
 248
 249 static boolean
 250 aout_adobe_mkobject (abfd)
 251      bfd *abfd;
 252 {
 253   struct bout_data_struct *rawptr;
 254
 255   rawptr = (struct bout_data_struct *) bfd_zalloc (abfd, sizeof (struct bout_data_struct));
 256   if (rawptr == NULL)
 257       return false;
 258
 259   abfd->tdata.bout_data = rawptr;
 260   exec_hdr (abfd) = &rawptr->e;
 261
 262   adata(abfd).reloc_entry_size = sizeof (struct reloc_std_external);
 263   adata(abfd).symbol_entry_size = sizeof (struct external_nlist);
 264   adata(abfd).page_size = 1; /* Not applicable. */
 265   adata(abfd).segment_size = 1; /* Not applicable. */
 266   adata(abfd).exec_bytes_size = EXEC_BYTES_SIZE;
 267
 268   return true;
 269 }
 270
 271
 272 static boolean
 273 aout_adobe_write_object_contents (abfd)
 274      bfd *abfd;
 275 {
 276   struct external_exec swapped_hdr;
 277   static struct external_segdesc sentinel[1];   /* Initialized to zero */
 278   asection *sect;
 279
 280   exec_hdr (abfd)->a_info = ZMAGIC;
 281
 282   /* Calculate text size as total of text sections, etc. */
 283
 284   exec_hdr (abfd)->a_text = 0;
 285   exec_hdr (abfd)->a_data = 0;
 286   exec_hdr (abfd)->a_bss  = 0;
 287   exec_hdr (abfd)->a_trsize = 0;
 288   exec_hdr (abfd)->a_drsize = 0;
 289
 290   for (sect = abfd->sections; sect; sect = sect->next) {
 291     if (sect->flags & SEC_CODE) {
 292       exec_hdr (abfd)->a_text += sect->_raw_size;
 293       exec_hdr (abfd)->a_trsize += sect->reloc_count *
 294                                    sizeof (struct reloc_std_external);
 295     } else if (sect->flags & SEC_DATA)  {
 296       exec_hdr (abfd)->a_data += sect->_raw_size;
 297       exec_hdr (abfd)->a_drsize += sect->reloc_count *
 298                                    sizeof (struct reloc_std_external);
 299     } else if (sect->flags & SEC_ALLOC && !(sect->flags & SEC_LOAD)) {
 300       exec_hdr (abfd)->a_bss  += sect->_raw_size;
 301     }
 302   }
 303
 304   exec_hdr (abfd)->a_syms = bfd_get_symcount (abfd)
 305                                 * sizeof (struct external_nlist);
 306   exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
 307
 308   aout_adobe_swap_exec_header_out (abfd, exec_hdr (abfd), &swapped_hdr);
 309
 310   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
 311       || (bfd_write ((PTR) &swapped_hdr, 1, EXEC_BYTES_SIZE, abfd)
 312           != EXEC_BYTES_SIZE))
 313     return false;
 314
 315   /* Now write out the section information.  Text first, data next, rest
 316      afterward.  */
 317
 318   for (sect = abfd->sections; sect; sect = sect->next) {
 319     if (sect->flags & SEC_CODE) {
 320       aout_adobe_write_section (abfd, sect);
 321     }
 322   }
 323   for (sect = abfd->sections; sect; sect = sect->next) {
 324     if (sect->flags & SEC_DATA) {
 325       aout_adobe_write_section (abfd, sect);
 326     }
 327   }
 328   for (sect = abfd->sections; sect; sect = sect->next) {
 329     if (!(sect->flags & (SEC_CODE|SEC_DATA))) {
 330       aout_adobe_write_section (abfd, sect);
 331     }
 332   }
 333
 334   /* Write final `sentinel` section header (with type of 0).  */
 335   if (bfd_write ((PTR) sentinel, 1, sizeof (*sentinel), abfd)
 336       != sizeof (*sentinel))
 337     return false;
 338
 339   /* Now write out reloc info, followed by syms and strings */
 340   if (bfd_get_symcount (abfd) != 0)
 341     {
 342       if (bfd_seek (abfd, (file_ptr)(N_SYMOFF(*exec_hdr(abfd))), SEEK_SET)
 343           != 0)
 344         return false;
 345
 346       if (! aout_32_write_syms (abfd))
 347         return false;
 348
 349       if (bfd_seek (abfd, (file_ptr)(N_TRELOFF(*exec_hdr(abfd))), SEEK_SET)
 350           != 0)
 351         return false;
 352
 353       for (sect = abfd->sections; sect; sect = sect->next) {
 354         if (sect->flags & SEC_CODE)     {
 355           if (!aout_32_squirt_out_relocs (abfd, sect))
 356             return false;
 357         }
 358       }
 359
 360       if (bfd_seek (abfd, (file_ptr)(N_DRELOFF(*exec_hdr(abfd))), SEEK_SET)
 361           != 0)
 362         return false;
 363
 364       for (sect = abfd->sections; sect; sect = sect->next) {
 365         if (sect->flags & SEC_DATA)     {
 366           if (!aout_32_squirt_out_relocs (abfd, sect))
 367             return false;
 368         }
 369       }
 370     }
 371   return true;
 372 }
 373
 374 static void
 375 aout_adobe_write_section (abfd, sect)
 376      bfd *abfd ATTRIBUTE_UNUSED;
 377      sec_ptr sect ATTRIBUTE_UNUSED;
 378 {
 379   /* FIXME XXX */
 380 }
 381 \f
 382 static boolean
 383 aout_adobe_set_section_contents (abfd, section, location, offset, count)
 384      bfd *abfd;
 385      asection *section;
 386      PTR location;
 387      file_ptr offset;
 388      bfd_size_type count;
 389 {
 390   file_ptr section_start;
 391   sec_ptr sect;
 392
 393   if (abfd->output_has_begun == false) { /* set by bfd.c handler */
 394
 395     /* Assign file offsets to sections.  Text sections are first, and
 396        are contiguous.  Then data sections.  Everything else at the end.  */
 397
 398     section_start = N_TXTOFF (ignore<-->me);
 399
 400     for (sect = abfd->sections; sect; sect = sect->next) {
 401       if (sect->flags & SEC_CODE)       {
 402         sect->filepos = section_start;
 403         /* FIXME:  Round to alignment */
 404         section_start += sect->_raw_size;
 405       }
 406     }
 407
 408     for (sect = abfd->sections; sect; sect = sect->next) {
 409       if (sect->flags & SEC_DATA)       {
 410         sect->filepos = section_start;
 411         /* FIXME:  Round to alignment */
 412         section_start += sect->_raw_size;
 413       }
 414     }
 415
 416     for (sect = abfd->sections; sect; sect = sect->next) {
 417       if (sect->flags & SEC_HAS_CONTENTS &&
 418           !(sect->flags & (SEC_CODE|SEC_DATA))) {
 419         sect->filepos = section_start;
 420         /* FIXME:  Round to alignment */
 421         section_start += sect->_raw_size;
 422       }
 423     }
 424   }
 425
 426   /* regardless, once we know what we're doing, we might as well get going */
 427   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
 428     return false;
 429
 430   if (count != 0) {
 431     return (bfd_write ((PTR)location, 1, count, abfd) == count) ?true:false;
 432   }
 433   return true;
 434 }
 435
 436 static boolean
 437 aout_adobe_set_arch_mach (abfd, arch, machine)
 438      bfd *abfd;
 439      enum bfd_architecture arch;
 440      unsigned long machine;
 441 {
 442   if (! bfd_default_set_arch_mach (abfd, arch, machine))
 443     return false;
 444
 445   if (arch == bfd_arch_unknown
 446       || arch == bfd_arch_m68k)
 447     return true;
 448
 449   return false;
 450 }
 451
 452 static int
 453 aout_adobe_sizeof_headers (ignore_abfd, ignore)
 454      bfd *ignore_abfd ATTRIBUTE_UNUSED;
 455      boolean ignore ATTRIBUTE_UNUSED;
 456 {
 457   return sizeof(struct internal_exec);
 458 }
 459
 460
 461
 462
 463 /* Build the transfer vector for Adobe A.Out files.  */
 464
 465 #define aout_32_close_and_cleanup aout_32_bfd_free_cached_info
 466
 467 #define aout_32_bfd_make_debug_symbol \
 468   ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
 469
 470 #define aout_32_bfd_reloc_type_lookup \
 471   ((reloc_howto_type *(*) \
 472     PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
 473
 474 #define aout_32_set_arch_mach           aout_adobe_set_arch_mach
 475 #define aout_32_set_section_contents    aout_adobe_set_section_contents
 476
 477 #define aout_32_sizeof_headers          aout_adobe_sizeof_headers
 478 #define aout_32_bfd_get_relocated_section_contents \
 479   bfd_generic_get_relocated_section_contents
 480 #define aout_32_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
 481 #define aout_32_bfd_relax_section       bfd_generic_relax_section
 482 #define aout_32_bfd_gc_sections         bfd_generic_gc_sections
 483 #define aout_32_bfd_link_hash_table_create \
 484   _bfd_generic_link_hash_table_create
 485 #define aout_32_bfd_link_add_symbols    _bfd_generic_link_add_symbols
 486 #define aout_32_bfd_final_link          _bfd_generic_final_link
 487 #define aout_32_bfd_link_split_section  _bfd_generic_link_split_section
 488
 489 const bfd_target a_out_adobe_vec =
 490 {
 491   "a.out.adobe",                /* name */
 492   bfd_target_aout_flavour,
 493   BFD_ENDIAN_BIG,               /* data byte order is unknown (big assumed) */
 494   BFD_ENDIAN_BIG,               /* hdr byte order is big */
 495   (HAS_RELOC | EXEC_P |         /* object flags */
 496    HAS_LINENO | HAS_DEBUG |
 497    HAS_SYMS | HAS_LOCALS | WP_TEXT ),
 498   /* section flags */
 499   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_DATA | SEC_RELOC),
 500   '_',                          /*  symbol leading char */
 501   ' ',                          /* ar_pad_char */
 502   16,                           /* ar_max_namelen */
 503
 504   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 505      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 506      bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
 507   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 508      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 509      bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
 510  {_bfd_dummy_target, aout_adobe_object_p, /* bfd_check_format */
 511    bfd_generic_archive_p, _bfd_dummy_target},
 512  {bfd_false, aout_adobe_mkobject, /* bfd_set_format */
 513    _bfd_generic_mkarchive, bfd_false},
 514  {bfd_false, aout_adobe_write_object_contents, /* bfd_write_contents */
 515    _bfd_write_archive_contents, bfd_false},
 516
 517      BFD_JUMP_TABLE_GENERIC (aout_32),
 518      BFD_JUMP_TABLE_COPY (_bfd_generic),
 519      BFD_JUMP_TABLE_CORE (_bfd_nocore),
 520      BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_bsd),
 521      BFD_JUMP_TABLE_SYMBOLS (aout_32),
 522      BFD_JUMP_TABLE_RELOCS (aout_32),
 523      BFD_JUMP_TABLE_WRITE (aout_32),
 524      BFD_JUMP_TABLE_LINK (aout_32),
 525      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 526
 527   NULL,
 528
 529   (PTR) 0
 530 };