OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [bfd/] [ppcboot.c] - Blame information for rev 842

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.