bfd/aout-adobe.c

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