bfd/ppcboot.c

   1 /* BFD back-end for PPCbug boot records.
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
   3    2007, 2008, 2009, 2011, 2012 Free Software Foundation, Inc.
   4    Written by Michael Meissner, Cygnus Support, <meissner@cygnus.com>
   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 3 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., 51 Franklin Street - Fifth Floor, Boston,
  21    MA 02110-1301, USA.  */
  22
  23
  24 /* This is a BFD backend which may be used to write PowerPCBug boot objects.
  25    It may only be used for output, not input.  The intention is that this may
  26    be used as an output format for objcopy in order to generate raw binary
  27    data.
  28
  29    This is very simple.  The only complication is that the real data
  30    will start at some address X, and in some cases we will not want to
  31    include X zeroes just to get to that point.  Since the start
  32    address is not meaningful for this object file format, we use it
  33    instead to indicate the number of zeroes to skip at the start of
  34    the file.  objcopy cooperates by specially setting the start
  35    address to zero by default.  */
  36
  37 #include "sysdep.h"
  38 #include "safe-ctype.h"
  39 #include "bfd.h"
  40 #include "libbfd.h"
  41
  42 /* PPCbug location structure */
  43 typedef struct ppcboot_location
  44 {
  45   bfd_byte      ind;
  46   bfd_byte      head;
  47   bfd_byte      sector;
  48   bfd_byte      cylinder;
  49 } ppcboot_location_t;
  50
  51 /* PPCbug partition table layout */
  52 typedef struct ppcboot_partition
  53 {
  54   ppcboot_location_t    partition_begin;        /* partition begin */
  55   ppcboot_location_t    partition_end;          /* partition end */
  56   bfd_byte              sector_begin[4];        /* 32-bit start RBA (zero-based), little endian */
  57   bfd_byte              sector_length[4];       /* 32-bit RBA count (one-based), little endian */
  58 } ppcboot_partition_t;
  59
  60 /* PPCbug boot layout.  */
  61 typedef struct ppcboot_hdr
  62 {
  63   bfd_byte              pc_compatibility[446];  /* x86 instruction field */
  64   ppcboot_partition_t   partition[4];           /* partition information */
  65   bfd_byte              signature[2];           /* 0x55 and 0xaa */
  66   bfd_byte              entry_offset[4];        /* entry point offset, little endian */
  67   bfd_byte              length[4];              /* load image length, little endian */
  68   bfd_byte              flags;                  /* flag field */
  69   bfd_byte              os_id;                  /* OS_ID */
  70   char                  partition_name[32];     /* partition name */
  71   bfd_byte              reserved1[470];         /* reserved */
  72 }
  73 #ifdef __GNUC__
  74   __attribute__ ((packed))
  75 #endif
  76 ppcboot_hdr_t;
  77
  78 /* Signature bytes for last 2 bytes of the 512 byte record */
  79 #define SIGNATURE0 0x55
  80 #define SIGNATURE1 0xaa
  81
  82 /* PowerPC boot type */
  83 #define PPC_IND 0x41
  84
  85 /* Information needed for ppcboot header */
  86 typedef struct ppcboot_data
  87 {
  88   ppcboot_hdr_t header;                         /* raw header */
  89   asection *sec;                                /* single section */
  90 } ppcboot_data_t;
  91
  92 /* Any bfd we create by reading a ppcboot file has three symbols:
  93    a start symbol, an end symbol, and an absolute length symbol.  */
  94 #define PPCBOOT_SYMS 3
  95
  96 #define ppcboot_set_tdata(abfd, ptr) ((abfd)->tdata.any = (ptr))
  97 #define ppcboot_get_tdata(abfd) ((ppcboot_data_t *) ((abfd)->tdata.any))
  98 \f
  99 /* Create a ppcboot object.  Invoked via bfd_set_format.  */
 100
 101 static bfd_boolean
 102 ppcboot_mkobject (bfd *abfd)
 103 {
 104   if (!ppcboot_get_tdata (abfd))
 105     {
 106       bfd_size_type amt = sizeof (ppcboot_data_t);
 107       ppcboot_set_tdata (abfd, bfd_zalloc (abfd, amt));
 108     }
 109
 110   return TRUE;
 111 }
 112
 113 \f
 114 /* Set the architecture to PowerPC */
 115 static bfd_boolean
 116 ppcboot_set_arch_mach (bfd *abfd,
 117                        enum bfd_architecture arch,
 118                        unsigned long machine)
 119 {
 120   if (arch == bfd_arch_unknown)
 121     arch = bfd_arch_powerpc;
 122
 123   else if (arch != bfd_arch_powerpc)
 124     return FALSE;
 125
 126   return bfd_default_set_arch_mach (abfd, arch, machine);
 127 }
 128
 129 \f
 130 /* Any file may be considered to be a ppcboot file, provided the target
 131    was not defaulted.  That is, it must be explicitly specified as
 132    being ppcboot.  */
 133
 134 static const bfd_target *
 135 ppcboot_object_p (bfd *abfd)
 136 {
 137   struct stat statbuf;
 138   asection *sec;
 139   ppcboot_hdr_t hdr;
 140   size_t i;
 141   ppcboot_data_t *tdata;
 142   flagword flags;
 143
 144   BFD_ASSERT (sizeof (ppcboot_hdr_t) == 1024);
 145
 146   if (abfd->target_defaulted)
 147     {
 148       bfd_set_error (bfd_error_wrong_format);
 149       return NULL;
 150     }
 151
 152   /* Find the file size.  */
 153   if (bfd_stat (abfd, &statbuf) < 0)
 154     {
 155       bfd_set_error (bfd_error_system_call);
 156       return NULL;
 157     }
 158
 159   if ((size_t) statbuf.st_size < sizeof (ppcboot_hdr_t))
 160     {
 161       bfd_set_error (bfd_error_wrong_format);
 162       return NULL;
 163     }
 164
 165   if (bfd_bread (&hdr, (bfd_size_type) sizeof (hdr), abfd)
 166       != sizeof (hdr))
 167     {
 168       if (bfd_get_error () != bfd_error_system_call)
 169         bfd_set_error (bfd_error_wrong_format);
 170
 171       return NULL;
 172     }
 173
 174   /* Now do some basic checks.  */
 175   for (i = 0; i < sizeof (hdr.pc_compatibility); i++)
 176     if (hdr.pc_compatibility[i])
 177       {
 178         bfd_set_error (bfd_error_wrong_format);
 179         return NULL;
 180       }
 181
 182   if (hdr.signature[0] != SIGNATURE0 || hdr.signature[1] != SIGNATURE1)
 183     {
 184       bfd_set_error (bfd_error_wrong_format);
 185       return NULL;
 186     }
 187
 188   if (hdr.partition[0].partition_end.ind != PPC_IND)
 189     {
 190       bfd_set_error (bfd_error_wrong_format);
 191       return NULL;
 192     }
 193
 194   abfd->symcount = PPCBOOT_SYMS;
 195
 196   /* One data section.  */
 197   flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_CODE | SEC_HAS_CONTENTS;
 198   sec = bfd_make_section_with_flags (abfd, ".data", flags);
 199   if (sec == NULL)
 200     return NULL;
 201   sec->vma = 0;
 202   sec->size = statbuf.st_size - sizeof (ppcboot_hdr_t);
 203   sec->filepos = sizeof (ppcboot_hdr_t);
 204
 205   ppcboot_mkobject (abfd);
 206   tdata = ppcboot_get_tdata (abfd);
 207   tdata->sec = sec;
 208   memcpy (&tdata->header, &hdr, sizeof (ppcboot_hdr_t));
 209
 210   ppcboot_set_arch_mach (abfd, bfd_arch_powerpc, 0L);
 211   return abfd->xvec;
 212 }
 213
 214 #define ppcboot_close_and_cleanup _bfd_generic_close_and_cleanup
 215 #define ppcboot_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
 216 #define ppcboot_new_section_hook _bfd_generic_new_section_hook
 217
 218 \f
 219 /* Get contents of the only section.  */
 220
 221 static bfd_boolean
 222 ppcboot_get_section_contents (bfd *abfd,
 223                               asection *section ATTRIBUTE_UNUSED,
 224                               void * location,
 225                               file_ptr offset,
 226                               bfd_size_type count)
 227 {
 228   if (bfd_seek (abfd, offset + (file_ptr) sizeof (ppcboot_hdr_t), SEEK_SET) != 0
 229       || bfd_bread (location, count, abfd) != count)
 230     return FALSE;
 231   return TRUE;
 232 }
 233
 234 \f
 235 /* Return the amount of memory needed to read the symbol table.  */
 236
 237 static long
 238 ppcboot_get_symtab_upper_bound (bfd *abfd ATTRIBUTE_UNUSED)
 239 {
 240   return (PPCBOOT_SYMS + 1) * sizeof (asymbol *);
 241 }
 242
 243 \f
 244 /* Create a symbol name based on the bfd's filename.  */
 245
 246 static char *
 247 mangle_name (bfd *abfd, char *suffix)
 248 {
 249   bfd_size_type size;
 250   char *buf;
 251   char *p;
 252
 253   size = (strlen (bfd_get_filename (abfd))
 254           + strlen (suffix)
 255           + sizeof "_ppcboot__");
 256
 257   buf = (char *) bfd_alloc (abfd, size);
 258   if (buf == NULL)
 259     return "";
 260
 261   sprintf (buf, "_ppcboot_%s_%s", bfd_get_filename (abfd), suffix);
 262
 263   /* Change any non-alphanumeric characters to underscores.  */
 264   for (p = buf; *p; p++)
 265     if (! ISALNUM (*p))
 266       *p = '_';
 267
 268   return buf;
 269 }
 270
 271 \f
 272 /* Return the symbol table.  */
 273
 274 static long
 275 ppcboot_canonicalize_symtab (bfd *abfd, asymbol **alocation)
 276 {
 277   asection *sec = ppcboot_get_tdata (abfd)->sec;
 278   asymbol *syms;
 279   unsigned int i;
 280   bfd_size_type amt = PPCBOOT_SYMS * sizeof (asymbol);
 281
 282   syms = (asymbol *) bfd_alloc (abfd, amt);
 283   if (syms == NULL)
 284     return FALSE;
 285
 286   /* Start symbol.  */
 287   syms[0].the_bfd = abfd;
 288   syms[0].name = mangle_name (abfd, "start");
 289   syms[0].value = 0;
 290   syms[0].flags = BSF_GLOBAL;
 291   syms[0].section = sec;
 292   syms[0].udata.p = NULL;
 293
 294   /* End symbol.  */
 295   syms[1].the_bfd = abfd;
 296   syms[1].name = mangle_name (abfd, "end");
 297   syms[1].value = sec->size;
 298   syms[1].flags = BSF_GLOBAL;
 299   syms[1].section = sec;
 300   syms[1].udata.p = NULL;
 301
 302   /* Size symbol.  */
 303   syms[2].the_bfd = abfd;
 304   syms[2].name = mangle_name (abfd, "size");
 305   syms[2].value = sec->size;
 306   syms[2].flags = BSF_GLOBAL;
 307   syms[2].section = bfd_abs_section_ptr;
 308   syms[2].udata.p = NULL;
 309
 310   for (i = 0; i < PPCBOOT_SYMS; i++)
 311     *alocation++ = syms++;
 312   *alocation = NULL;
 313
 314   return PPCBOOT_SYMS;
 315 }
 316
 317 #define ppcboot_make_empty_symbol _bfd_generic_make_empty_symbol
 318 #define ppcboot_print_symbol _bfd_nosymbols_print_symbol
 319
 320 /* Get information about a symbol.  */
 321
 322 static void
 323 ppcboot_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
 324                          asymbol *symbol,
 325                          symbol_info *ret)
 326 {
 327   bfd_symbol_info (symbol, ret);
 328 }
 329
 330 #define ppcboot_bfd_is_target_special_symbol \
 331   ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
 332 #define ppcboot_bfd_is_local_label_name bfd_generic_is_local_label_name
 333 #define ppcboot_get_lineno _bfd_nosymbols_get_lineno
 334 #define ppcboot_find_nearest_line _bfd_nosymbols_find_nearest_line
 335 #define ppcboot_find_inliner_info _bfd_nosymbols_find_inliner_info
 336 #define ppcboot_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
 337 #define ppcboot_read_minisymbols _bfd_generic_read_minisymbols
 338 #define ppcboot_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
 339 \f
 340 /* Write section contents of a ppcboot file.  */
 341
 342 static bfd_boolean
 343 ppcboot_set_section_contents (bfd *abfd,
 344                               asection *sec,
 345                               const void * data,
 346                               file_ptr offset,
 347                               bfd_size_type size)
 348 {
 349   if (! abfd->output_has_begun)
 350     {
 351       bfd_vma low;
 352       asection *s;
 353
 354       /* The lowest section VMA sets the virtual address of the start
 355          of the file.  We use the set the file position of all the
 356          sections.  */
 357       low = abfd->sections->vma;
 358       for (s = abfd->sections->next; s != NULL; s = s->next)
 359         if (s->vma < low)
 360           low = s->vma;
 361
 362       for (s = abfd->sections; s != NULL; s = s->next)
 363         s->filepos = s->vma - low;
 364
 365       abfd->output_has_begun = TRUE;
 366     }
 367
 368   return _bfd_generic_set_section_contents (abfd, sec, data, offset, size);
 369 }
 370
 371 \f
 372 static int
 373 ppcboot_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
 374                         struct bfd_link_info *info ATTRIBUTE_UNUSED)
 375 {
 376   return sizeof (ppcboot_hdr_t);
 377 }
 378
 379 \f
 380 /* Print out the program headers.  */
 381
 382 static bfd_boolean
 383 ppcboot_bfd_print_private_bfd_data (bfd *abfd, void * farg)
 384 {
 385   FILE *f = (FILE *)farg;
 386   ppcboot_data_t *tdata = ppcboot_get_tdata (abfd);
 387   long entry_offset = bfd_getl_signed_32 (tdata->header.entry_offset);
 388   long length = bfd_getl_signed_32 (tdata->header.length);
 389   int i;
 390
 391   fprintf (f, _("\nppcboot header:\n"));
 392   fprintf (f, _("Entry offset        = 0x%.8lx (%ld)\n"),
 393            (unsigned long) entry_offset, entry_offset);
 394   fprintf (f, _("Length              = 0x%.8lx (%ld)\n"),
 395            (unsigned long) length, length);
 396
 397   if (tdata->header.flags)
 398     fprintf (f, _("Flag field          = 0x%.2x\n"), tdata->header.flags);
 399
 400   if (tdata->header.os_id)
 401     fprintf (f, "OS_ID               = 0x%.2x\n", tdata->header.os_id);
 402
 403   if (tdata->header.partition_name)
 404     fprintf (f, _("Partition name      = \"%s\"\n"), tdata->header.partition_name);
 405
 406   for (i = 0; i < 4; i++)
 407     {
 408       long sector_begin  = bfd_getl_signed_32 (tdata->header.partition[i].sector_begin);
 409       long sector_length = bfd_getl_signed_32 (tdata->header.partition[i].sector_length);
 410
 411       /* Skip all 0 entries */
 412       if (!tdata->header.partition[i].partition_begin.ind
 413           && !tdata->header.partition[i].partition_begin.head
 414           && !tdata->header.partition[i].partition_begin.sector
 415           && !tdata->header.partition[i].partition_begin.cylinder
 416           && !tdata->header.partition[i].partition_end.ind
 417           && !tdata->header.partition[i].partition_end.head
 418           && !tdata->header.partition[i].partition_end.sector
 419           && !tdata->header.partition[i].partition_end.cylinder
 420           && !sector_begin && !sector_length)
 421         continue;
 422
 423       fprintf (f, _("\nPartition[%d] start  = { 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x }\n"), i,
 424                tdata->header.partition[i].partition_begin.ind,
 425                tdata->header.partition[i].partition_begin.head,
 426                tdata->header.partition[i].partition_begin.sector,
 427                tdata->header.partition[i].partition_begin.cylinder);
 428
 429       fprintf (f, _("Partition[%d] end    = { 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x }\n"), i,
 430                tdata->header.partition[i].partition_end.ind,
 431                tdata->header.partition[i].partition_end.head,
 432                tdata->header.partition[i].partition_end.sector,
 433                tdata->header.partition[i].partition_end.cylinder);
 434
 435       fprintf (f, _("Partition[%d] sector = 0x%.8lx (%ld)\n"),
 436                i, (unsigned long) sector_begin, sector_begin);
 437       fprintf (f, _("Partition[%d] length = 0x%.8lx (%ld)\n"),
 438                i, (unsigned long) sector_length, sector_length);
 439     }
 440
 441   fprintf (f, "\n");
 442   return TRUE;
 443 }
 444
 445 \f
 446 #define ppcboot_bfd_get_relocated_section_contents \
 447   bfd_generic_get_relocated_section_contents
 448 #define ppcboot_bfd_relax_section bfd_generic_relax_section
 449 #define ppcboot_bfd_gc_sections bfd_generic_gc_sections
 450 #define ppcboot_bfd_lookup_section_flags bfd_generic_lookup_section_flags
 451 #define ppcboot_bfd_merge_sections bfd_generic_merge_sections
 452 #define ppcboot_bfd_is_group_section bfd_generic_is_group_section
 453 #define ppcboot_bfd_discard_group bfd_generic_discard_group
 454 #define ppcboot_section_already_linked \
 455   _bfd_generic_section_already_linked
 456 #define ppcboot_bfd_define_common_symbol bfd_generic_define_common_symbol
 457 #define ppcboot_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
 458 #define ppcboot_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
 459 #define ppcboot_bfd_link_add_symbols _bfd_generic_link_add_symbols
 460 #define ppcboot_bfd_link_just_syms _bfd_generic_link_just_syms
 461 #define ppcboot_bfd_copy_link_hash_symbol_type \
 462   _bfd_generic_copy_link_hash_symbol_type
 463 #define ppcboot_bfd_final_link _bfd_generic_final_link
 464 #define ppcboot_bfd_link_split_section _bfd_generic_link_split_section
 465 #define ppcboot_get_section_contents_in_window \
 466   _bfd_generic_get_section_contents_in_window
 467
 468 #define ppcboot_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
 469 #define ppcboot_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
 470 #define ppcboot_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
 471 #define ppcboot_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
 472 #define ppcboot_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
 473 #define ppcboot_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
 474 #define ppcboot_bfd_print_private_bfd_dat ppcboot_bfd_print_private_bfd_data
 475
 476 const bfd_target ppcboot_vec =
 477 {
 478   "ppcboot",                    /* name */
 479   bfd_target_unknown_flavour,   /* flavour */
 480   BFD_ENDIAN_BIG,               /* byteorder is big endian for code */
 481   BFD_ENDIAN_LITTLE,            /* header_byteorder */
 482   EXEC_P,                       /* object_flags */
 483   (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_DATA
 484    | SEC_ROM | SEC_HAS_CONTENTS), /* section_flags */
 485   0,                            /* symbol_leading_char */
 486   ' ',                          /* ar_pad_char */
 487   16,                           /* ar_max_namelen */
 488   0,                            /* match priority.  */
 489   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 490   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 491   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* data */
 492   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 493   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 494   bfd_getl16, bfd_getl_signed_16, bfd_putl16,   /* hdrs */
 495   {                             /* bfd_check_format */
 496     _bfd_dummy_target,
 497     ppcboot_object_p,           /* bfd_check_format */
 498     _bfd_dummy_target,
 499     _bfd_dummy_target,
 500   },
 501   {                             /* bfd_set_format */
 502     bfd_false,
 503     ppcboot_mkobject,
 504     bfd_false,
 505     bfd_false,
 506   },
 507   {                             /* bfd_write_contents */
 508     bfd_false,
 509     bfd_true,
 510     bfd_false,
 511     bfd_false,
 512   },
 513
 514   BFD_JUMP_TABLE_GENERIC (ppcboot),
 515   BFD_JUMP_TABLE_COPY (ppcboot),
 516   BFD_JUMP_TABLE_CORE (_bfd_nocore),
 517   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
 518   BFD_JUMP_TABLE_SYMBOLS (ppcboot),
 519   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
 520   BFD_JUMP_TABLE_WRITE (ppcboot),
 521   BFD_JUMP_TABLE_LINK (ppcboot),
 522   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 523
 524   NULL,
 525
 526   NULL
 527 };