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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [bfd/] [xsym.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* xSYM symbol-file support for BFD.
2
   Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3
   2009 Free Software Foundation, Inc.
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 3 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., 51 Franklin Street - Fifth Floor, Boston,
20
   MA 02110-1301, USA.  */
21
 
22
#include "alloca-conf.h"
23
#include "sysdep.h"
24
#include "xsym.h"
25
#include "bfd.h"
26
#include "libbfd.h"
27
 
28
#define bfd_sym_close_and_cleanup                   _bfd_generic_close_and_cleanup
29
#define bfd_sym_bfd_free_cached_info                _bfd_generic_bfd_free_cached_info
30
#define bfd_sym_new_section_hook                    _bfd_generic_new_section_hook
31
#define bfd_sym_bfd_is_local_label_name             bfd_generic_is_local_label_name
32
#define bfd_sym_bfd_is_target_special_symbol       ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
33
#define bfd_sym_get_lineno                          _bfd_nosymbols_get_lineno
34
#define bfd_sym_find_nearest_line                   _bfd_nosymbols_find_nearest_line
35
#define bfd_sym_find_inliner_info                   _bfd_nosymbols_find_inliner_info
36
#define bfd_sym_bfd_make_debug_symbol               _bfd_nosymbols_bfd_make_debug_symbol
37
#define bfd_sym_read_minisymbols                    _bfd_generic_read_minisymbols
38
#define bfd_sym_minisymbol_to_symbol                _bfd_generic_minisymbol_to_symbol
39
#define bfd_sym_set_arch_mach                       _bfd_generic_set_arch_mach
40
#define bfd_sym_get_section_contents                _bfd_generic_get_section_contents
41
#define bfd_sym_set_section_contents                _bfd_generic_set_section_contents
42
#define bfd_sym_bfd_get_relocated_section_contents  bfd_generic_get_relocated_section_contents
43
#define bfd_sym_bfd_relax_section                   bfd_generic_relax_section
44
#define bfd_sym_bfd_gc_sections                     bfd_generic_gc_sections
45
#define bfd_sym_bfd_merge_sections                  bfd_generic_merge_sections
46
#define bfd_sym_bfd_is_group_section                bfd_generic_is_group_section
47
#define bfd_sym_bfd_discard_group                   bfd_generic_discard_group
48
#define bfd_sym_section_already_linked              _bfd_generic_section_already_linked
49
#define bfd_sym_bfd_define_common_symbol            bfd_generic_define_common_symbol
50
#define bfd_sym_bfd_link_hash_table_create          _bfd_generic_link_hash_table_create
51
#define bfd_sym_bfd_link_hash_table_free            _bfd_generic_link_hash_table_free
52
#define bfd_sym_bfd_link_add_symbols                _bfd_generic_link_add_symbols
53
#define bfd_sym_bfd_link_just_syms                  _bfd_generic_link_just_syms
54
#define bfd_sym_bfd_copy_link_hash_symbol_type \
55
  _bfd_generic_copy_link_hash_symbol_type
56
#define bfd_sym_bfd_final_link                      _bfd_generic_final_link
57
#define bfd_sym_bfd_link_split_section              _bfd_generic_link_split_section
58
#define bfd_sym_get_section_contents_in_window      _bfd_generic_get_section_contents_in_window
59
 
60
extern const bfd_target sym_vec;
61
 
62
static int
63
pstrcmp (const char *as, const char *bs)
64
{
65
  const unsigned char *a = (const unsigned char *) as;
66
  const unsigned char *b = (const unsigned char *) bs;
67
  unsigned char clen;
68
  int ret;
69
 
70
  clen = (a[0] > b[0]) ? b[0] : a[0];
71
  ret = memcmp (a + 1, b + 1, clen);
72
  if (ret != 0)
73
    return ret;
74
 
75
  if (a[0] == b[0])
76
    return 0;
77
  else if (a[0] < b[0])
78
    return -1;
79
  else
80
    return 1;
81
}
82
 
83
static unsigned long
84
compute_offset (unsigned long first_page,
85
                unsigned long page_size,
86
                unsigned long entry_size,
87
                unsigned long sym_index)
88
{
89
  unsigned long entries_per_page = page_size / entry_size;
90
  unsigned long page_number = first_page + (sym_index / entries_per_page);
91
  unsigned long page_offset = (sym_index % entries_per_page) * entry_size;
92
 
93
  return (page_number * page_size) + page_offset;
94
}
95
 
96
bfd_boolean
97
bfd_sym_mkobject (bfd *abfd ATTRIBUTE_UNUSED)
98
{
99
  return 1;
100
}
101
 
102
void
103
bfd_sym_print_symbol (bfd *abfd ATTRIBUTE_UNUSED,
104
                      void * afile ATTRIBUTE_UNUSED,
105
                      asymbol *symbol ATTRIBUTE_UNUSED,
106
                      bfd_print_symbol_type how ATTRIBUTE_UNUSED)
107
{
108
  return;
109
}
110
 
111
bfd_boolean
112
bfd_sym_valid (bfd *abfd)
113
{
114
  if (abfd == NULL || abfd->xvec == NULL)
115
    return 0;
116
 
117
  return abfd->xvec == &sym_vec;
118
}
119
 
120
unsigned char *
121
bfd_sym_read_name_table (bfd *abfd, bfd_sym_header_block *dshb)
122
{
123
  unsigned char *rstr;
124
  long ret;
125
  size_t table_size = dshb->dshb_nte.dti_page_count * dshb->dshb_page_size;
126
  size_t table_offset = dshb->dshb_nte.dti_first_page * dshb->dshb_page_size;
127
 
128
  rstr = bfd_alloc (abfd, table_size);
129
  if (rstr == NULL)
130
    return rstr;
131
 
132
  bfd_seek (abfd, table_offset, SEEK_SET);
133
  ret = bfd_bread (rstr, table_size, abfd);
134
  if (ret < 0 || (unsigned long) ret != table_size)
135
    {
136
      bfd_release (abfd, rstr);
137
      return NULL;
138
    }
139
 
140
  return rstr;
141
}
142
 
143
void
144
bfd_sym_parse_file_reference_v32 (unsigned char *buf,
145
                                  size_t len,
146
                                  bfd_sym_file_reference *entry)
147
{
148
  BFD_ASSERT (len == 6);
149
 
150
  entry->fref_frte_index = bfd_getb16 (buf);
151
  entry->fref_offset = bfd_getb32 (buf + 2);
152
}
153
 
154
void
155
bfd_sym_parse_disk_table_v32 (unsigned char *buf,
156
                              size_t len,
157
                              bfd_sym_table_info *table)
158
{
159
  BFD_ASSERT (len == 8);
160
 
161
  table->dti_first_page = bfd_getb16 (buf);
162
  table->dti_page_count = bfd_getb16 (buf + 2);
163
  table->dti_object_count = bfd_getb32 (buf + 4);
164
}
165
 
166
void
167
bfd_sym_parse_header_v32 (unsigned char *buf,
168
                          size_t len,
169
                          bfd_sym_header_block *header)
170
{
171
  BFD_ASSERT (len == 154);
172
 
173
  memcpy (header->dshb_id, buf, 32);
174
  header->dshb_page_size = bfd_getb16 (buf + 32);
175
  header->dshb_hash_page = bfd_getb16 (buf + 34);
176
  header->dshb_root_mte = bfd_getb16 (buf + 36);
177
  header->dshb_mod_date = bfd_getb32 (buf + 38);
178
 
179
  bfd_sym_parse_disk_table_v32 (buf + 42, 8, &header->dshb_frte);
180
  bfd_sym_parse_disk_table_v32 (buf + 50, 8, &header->dshb_rte);
181
  bfd_sym_parse_disk_table_v32 (buf + 58, 8, &header->dshb_mte);
182
  bfd_sym_parse_disk_table_v32 (buf + 66, 8, &header->dshb_cmte);
183
  bfd_sym_parse_disk_table_v32 (buf + 74, 8, &header->dshb_cvte);
184
  bfd_sym_parse_disk_table_v32 (buf + 82, 8, &header->dshb_csnte);
185
  bfd_sym_parse_disk_table_v32 (buf + 90, 8, &header->dshb_clte);
186
  bfd_sym_parse_disk_table_v32 (buf + 98, 8, &header->dshb_ctte);
187
  bfd_sym_parse_disk_table_v32 (buf + 106, 8, &header->dshb_tte);
188
  bfd_sym_parse_disk_table_v32 (buf + 114, 8, &header->dshb_nte);
189
  bfd_sym_parse_disk_table_v32 (buf + 122, 8, &header->dshb_tinfo);
190
  bfd_sym_parse_disk_table_v32 (buf + 130, 8, &header->dshb_fite);
191
  bfd_sym_parse_disk_table_v32 (buf + 138, 8, &header->dshb_const);
192
 
193
  memcpy (&header->dshb_file_creator, buf + 146, 4);
194
  memcpy (&header->dshb_file_type, buf + 150, 4);
195
}
196
 
197
int
198
bfd_sym_read_header_v32 (bfd *abfd, bfd_sym_header_block *header)
199
{
200
  unsigned char buf[154];
201
  long ret;
202
 
203
  ret = bfd_bread (buf, 154, abfd);
204
  if (ret != 154)
205
    return -1;
206
 
207
  bfd_sym_parse_header_v32 (buf, 154, header);
208
 
209
  return 0;
210
}
211
 
212
int
213
bfd_sym_read_header_v34 (bfd *abfd ATTRIBUTE_UNUSED,
214
                         bfd_sym_header_block *header ATTRIBUTE_UNUSED)
215
{
216
  abort ();
217
}
218
 
219
int
220
bfd_sym_read_header (bfd *abfd,
221
                     bfd_sym_header_block *header,
222
                     bfd_sym_version version)
223
{
224
  switch (version)
225
    {
226
    case BFD_SYM_VERSION_3_5:
227
    case BFD_SYM_VERSION_3_4:
228
      return bfd_sym_read_header_v34 (abfd, header);
229
    case BFD_SYM_VERSION_3_3:
230
    case BFD_SYM_VERSION_3_2:
231
      return bfd_sym_read_header_v32 (abfd, header);
232
    case BFD_SYM_VERSION_3_1:
233
    default:
234
      return 0;
235
    }
236
}
237
 
238
int
239
bfd_sym_read_version (bfd *abfd, bfd_sym_version *version)
240
{
241
  char version_string[32];
242
  long ret;
243
 
244
  ret = bfd_bread (version_string, sizeof (version_string), abfd);
245
  if (ret != sizeof (version_string))
246
    return -1;
247
 
248
  if (pstrcmp (version_string, BFD_SYM_VERSION_STR_3_1) == 0)
249
    *version = BFD_SYM_VERSION_3_1;
250
  else if (pstrcmp (version_string, BFD_SYM_VERSION_STR_3_2) == 0)
251
    *version = BFD_SYM_VERSION_3_2;
252
  else if (pstrcmp (version_string, BFD_SYM_VERSION_STR_3_3) == 0)
253
    *version = BFD_SYM_VERSION_3_3;
254
  else if (pstrcmp (version_string, BFD_SYM_VERSION_STR_3_4) == 0)
255
    *version = BFD_SYM_VERSION_3_4;
256
  else if (pstrcmp (version_string, BFD_SYM_VERSION_STR_3_5) == 0)
257
    *version = BFD_SYM_VERSION_3_5;
258
  else
259
    return -1;
260
 
261
  return 0;
262
}
263
 
264
void
265
bfd_sym_display_table_summary (FILE *f,
266
                               bfd_sym_table_info *dti,
267
                               const char *name)
268
{
269
  fprintf (f, "%-6s %13ld %13ld %13ld\n",
270
           name,
271
           dti->dti_first_page,
272
           dti->dti_page_count,
273
           dti->dti_object_count);
274
}
275
 
276
void
277
bfd_sym_display_header (FILE *f, bfd_sym_header_block *dshb)
278
{
279
  fprintf (f, "            Version: %.*s\n", dshb->dshb_id[0], dshb->dshb_id + 1);
280
  fprintf (f, "          Page Size: 0x%x\n", dshb->dshb_page_size);
281
  fprintf (f, "          Hash Page: %lu\n", dshb->dshb_hash_page);
282
  fprintf (f, "           Root MTE: %lu\n", dshb->dshb_root_mte);
283
  fprintf (f, "  Modification Date: ");
284
  fprintf (f, "[unimplemented]");
285
  fprintf (f, " (0x%lx)\n", dshb->dshb_mod_date);
286
 
287
  fprintf (f, "       File Creator:  %.4s  Type: %.4s\n\n",
288
           dshb->dshb_file_creator, dshb->dshb_file_type);
289
 
290
  fprintf (f, "Table Name   First Page    Page Count   Object Count\n");
291
  fprintf (f, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
292
 
293
  bfd_sym_display_table_summary (f, &dshb->dshb_nte, "NTE");
294
  bfd_sym_display_table_summary (f, &dshb->dshb_rte, "RTE");
295
  bfd_sym_display_table_summary (f, &dshb->dshb_mte, "MTE");
296
  bfd_sym_display_table_summary (f, &dshb->dshb_frte, "FRTE");
297
  bfd_sym_display_table_summary (f, &dshb->dshb_cmte, "CMTE");
298
  bfd_sym_display_table_summary (f, &dshb->dshb_cvte, "CVTE");
299
  bfd_sym_display_table_summary (f, &dshb->dshb_csnte, "CSNTE");
300
  bfd_sym_display_table_summary (f, &dshb->dshb_clte, "CLTE");
301
  bfd_sym_display_table_summary (f, &dshb->dshb_ctte, "CTTE");
302
  bfd_sym_display_table_summary (f, &dshb->dshb_tte, "TTE");
303
  bfd_sym_display_table_summary (f, &dshb->dshb_tinfo, "TINFO");
304
  bfd_sym_display_table_summary (f, &dshb->dshb_fite, "FITE");
305
  bfd_sym_display_table_summary (f, &dshb->dshb_const, "CONST");
306
 
307
  fprintf (f, "\n");
308
}
309
 
310
void
311
bfd_sym_parse_resources_table_entry_v32 (unsigned char *buf,
312
                                         size_t len,
313
                                         bfd_sym_resources_table_entry *entry)
314
{
315
  BFD_ASSERT (len == 18);
316
 
317
  memcpy (&entry->rte_res_type, buf, 4);
318
  entry->rte_res_number = bfd_getb16 (buf + 4);
319
  entry->rte_nte_index = bfd_getb32 (buf + 6);
320
  entry->rte_mte_first = bfd_getb16 (buf + 10);
321
  entry->rte_mte_last = bfd_getb16 (buf + 12);
322
  entry->rte_res_size = bfd_getb32 (buf + 14);
323
}
324
 
325
void
326
bfd_sym_parse_modules_table_entry_v33 (unsigned char *buf,
327
                                       size_t len,
328
                                       bfd_sym_modules_table_entry *entry)
329
{
330
  BFD_ASSERT (len == 46);
331
 
332
  entry->mte_rte_index = bfd_getb16 (buf);
333
  entry->mte_res_offset = bfd_getb32 (buf + 2);
334
  entry->mte_size = bfd_getb32 (buf + 6);
335
  entry->mte_kind = buf[10];
336
  entry->mte_scope = buf[11];
337
  entry->mte_parent = bfd_getb16 (buf + 12);
338
  bfd_sym_parse_file_reference_v32 (buf + 14, 6, &entry->mte_imp_fref);
339
  entry->mte_imp_end = bfd_getb32 (buf + 20);
340
  entry->mte_nte_index = bfd_getb32 (buf + 24);
341
  entry->mte_cmte_index = bfd_getb16 (buf + 28);
342
  entry->mte_cvte_index = bfd_getb32 (buf + 30);
343
  entry->mte_clte_index = bfd_getb16 (buf + 34);
344
  entry->mte_ctte_index = bfd_getb16 (buf + 36);
345
  entry->mte_csnte_idx_1 = bfd_getb32 (buf + 38);
346
  entry->mte_csnte_idx_2 = bfd_getb32 (buf + 42);
347
}
348
 
349
void
350
bfd_sym_parse_file_references_table_entry_v32 (unsigned char *buf,
351
                                               size_t len,
352
                                               bfd_sym_file_references_table_entry *entry)
353
{
354
  unsigned int type;
355
 
356
  BFD_ASSERT (len == 10);
357
 
358
  memset (entry, 0, sizeof (bfd_sym_file_references_table_entry));
359
  type = bfd_getb16 (buf);
360
 
361
  switch (type)
362
    {
363
    case BFD_SYM_END_OF_LIST_3_2:
364
      entry->generic.type = BFD_SYM_END_OF_LIST;
365
      break;
366
 
367
    case BFD_SYM_FILE_NAME_INDEX_3_2:
368
      entry->filename.type = BFD_SYM_FILE_NAME_INDEX;
369
      entry->filename.nte_index = bfd_getb32 (buf + 2);
370
      entry->filename.mod_date = bfd_getb32 (buf + 6);
371
      break;
372
 
373
    default:
374
      entry->entry.mte_index = type;
375
      entry->entry.file_offset = bfd_getb32 (buf + 2);
376
    }
377
}
378
 
379
void
380
bfd_sym_parse_contained_modules_table_entry_v32 (unsigned char *buf,
381
                                                 size_t len,
382
                                                 bfd_sym_contained_modules_table_entry *entry)
383
{
384
  unsigned int type;
385
 
386
  BFD_ASSERT (len == 6);
387
 
388
  memset (entry, 0, sizeof (bfd_sym_contained_modules_table_entry));
389
  type = bfd_getb16 (buf);
390
 
391
  switch (type)
392
    {
393
    case BFD_SYM_END_OF_LIST_3_2:
394
      entry->generic.type = BFD_SYM_END_OF_LIST;
395
      break;
396
 
397
    default:
398
      entry->entry.mte_index = type;
399
      entry->entry.nte_index = bfd_getb32 (buf + 2);
400
      break;
401
    }
402
}
403
 
404
void
405
bfd_sym_parse_contained_variables_table_entry_v32 (unsigned char *buf,
406
                                                   size_t len,
407
                                                   bfd_sym_contained_variables_table_entry *entry)
408
{
409
  unsigned int type;
410
 
411
  BFD_ASSERT (len == 26);
412
 
413
  memset (entry, 0, sizeof (bfd_sym_contained_variables_table_entry));
414
  type = bfd_getb16 (buf);
415
 
416
  switch (type)
417
    {
418
    case BFD_SYM_END_OF_LIST_3_2:
419
      entry->generic.type = BFD_SYM_END_OF_LIST;
420
      break;
421
 
422
    case BFD_SYM_SOURCE_FILE_CHANGE_3_2:
423
      entry->file.type = BFD_SYM_SOURCE_FILE_CHANGE;
424
      bfd_sym_parse_file_reference_v32 (buf + 2, 6, &entry->file.fref);
425
      break;
426
 
427
    default:
428
      entry->entry.tte_index = type;
429
      entry->entry.nte_index = bfd_getb32 (buf + 2);
430
      entry->entry.file_delta = bfd_getb16 (buf + 6);
431
      entry->entry.scope = buf[8];
432
      entry->entry.la_size = buf[9];
433
 
434
      if (entry->entry.la_size == BFD_SYM_CVTE_SCA)
435
        {
436
          entry->entry.address.scstruct.sca_kind = buf[10];
437
          entry->entry.address.scstruct.sca_class = buf[11];
438
          entry->entry.address.scstruct.sca_offset = bfd_getb32 (buf + 12);
439
        }
440
      else if (entry->entry.la_size <= BFD_SYM_CVTE_SCA)
441
        {
442
#if BFD_SYM_CVTE_SCA > 0
443
          memcpy (&entry->entry.address.lastruct.la, buf + 10,
444
                  BFD_SYM_CVTE_SCA);
445
#endif
446
          entry->entry.address.lastruct.la_kind = buf[23];
447
        }
448
      else if (entry->entry.la_size == BFD_SYM_CVTE_BIG_LA)
449
        {
450
          entry->entry.address.biglastruct.big_la = bfd_getb32 (buf + 10);
451
          entry->entry.address.biglastruct.big_la_kind = buf[12];
452
        }
453
    }
454
}
455
 
456
void
457
bfd_sym_parse_contained_statements_table_entry_v32 (unsigned char *buf,
458
                                                    size_t len,
459
                                                    bfd_sym_contained_statements_table_entry *entry)
460
{
461
  unsigned int type;
462
 
463
  BFD_ASSERT (len == 8);
464
 
465
  memset (entry, 0, sizeof (bfd_sym_contained_statements_table_entry));
466
  type = bfd_getb16 (buf);
467
 
468
  switch (type)
469
    {
470
    case BFD_SYM_END_OF_LIST_3_2:
471
      entry->generic.type = BFD_SYM_END_OF_LIST;
472
      break;
473
 
474
    case BFD_SYM_SOURCE_FILE_CHANGE_3_2:
475
      entry->file.type = BFD_SYM_SOURCE_FILE_CHANGE;
476
      bfd_sym_parse_file_reference_v32 (buf + 2, 6, &entry->file.fref);
477
      break;
478
 
479
    default:
480
      entry->entry.mte_index = type;
481
      entry->entry.mte_offset = bfd_getb16 (buf + 2);
482
      entry->entry.file_delta = bfd_getb32 (buf + 4);
483
      break;
484
    }
485
}
486
 
487
void
488
bfd_sym_parse_contained_labels_table_entry_v32 (unsigned char *buf,
489
                                                size_t len,
490
                                                bfd_sym_contained_labels_table_entry *entry)
491
{
492
  unsigned int type;
493
 
494
  BFD_ASSERT (len == 12);
495
 
496
  memset (entry, 0, sizeof (bfd_sym_contained_labels_table_entry));
497
  type = bfd_getb16 (buf);
498
 
499
  switch (type)
500
    {
501
    case BFD_SYM_END_OF_LIST_3_2:
502
      entry->generic.type = BFD_SYM_END_OF_LIST;
503
      break;
504
 
505
    case BFD_SYM_SOURCE_FILE_CHANGE_3_2:
506
      entry->file.type = BFD_SYM_SOURCE_FILE_CHANGE;
507
      bfd_sym_parse_file_reference_v32 (buf + 2, 6, &entry->file.fref);
508
      break;
509
 
510
    default:
511
      entry->entry.mte_index = type;
512
      entry->entry.mte_offset = bfd_getb16 (buf + 2);
513
      entry->entry.nte_index = bfd_getb32 (buf + 4);
514
      entry->entry.file_delta = bfd_getb16 (buf + 8);
515
      entry->entry.scope = bfd_getb16 (buf + 10);
516
      break;
517
    }
518
}
519
 
520
void
521
bfd_sym_parse_type_table_entry_v32 (unsigned char *buf,
522
                                    size_t len,
523
                                    bfd_sym_type_table_entry *entry)
524
{
525
  BFD_ASSERT (len == 4);
526
 
527
  *entry = bfd_getb32 (buf);
528
}
529
 
530
int
531
bfd_sym_fetch_resources_table_entry (bfd *abfd,
532
                                     bfd_sym_resources_table_entry *entry,
533
                                     unsigned long sym_index)
534
{
535
  void (*parser) (unsigned char *, size_t, bfd_sym_resources_table_entry *);
536
  unsigned long offset;
537
  unsigned long entry_size;
538
  unsigned char buf[18];
539
  bfd_sym_data_struct *sdata = NULL;
540
 
541
  parser = NULL;
542
  BFD_ASSERT (bfd_sym_valid (abfd));
543
  sdata = abfd->tdata.sym_data;
544
 
545
  if (sym_index == 0)
546
    return -1;
547
 
548
  switch (sdata->version)
549
    {
550
    case BFD_SYM_VERSION_3_5:
551
    case BFD_SYM_VERSION_3_4:
552
      return -1;
553
 
554
    case BFD_SYM_VERSION_3_3:
555
    case BFD_SYM_VERSION_3_2:
556
      entry_size = 18;
557
      parser = bfd_sym_parse_resources_table_entry_v32;
558
      break;
559
 
560
    case BFD_SYM_VERSION_3_1:
561
    default:
562
      return -1;
563
    }
564
  if (parser == NULL)
565
    return -1;
566
 
567
  offset = compute_offset (sdata->header.dshb_rte.dti_first_page,
568
                           sdata->header.dshb_page_size,
569
                           entry_size, sym_index);
570
 
571
  if (bfd_seek (abfd, offset, SEEK_SET) < 0)
572
    return -1;
573
  if (bfd_bread (buf, entry_size, abfd) != entry_size)
574
    return -1;
575
 
576
  (*parser) (buf, entry_size, entry);
577
 
578
  return 0;
579
}
580
 
581
int
582
bfd_sym_fetch_modules_table_entry (bfd *abfd,
583
                                   bfd_sym_modules_table_entry *entry,
584
                                   unsigned long sym_index)
585
{
586
  void (*parser) (unsigned char *, size_t, bfd_sym_modules_table_entry *);
587
  unsigned long offset;
588
  unsigned long entry_size;
589
  unsigned char buf[46];
590
  bfd_sym_data_struct *sdata = NULL;
591
 
592
  parser = NULL;
593
  BFD_ASSERT (bfd_sym_valid (abfd));
594
  sdata = abfd->tdata.sym_data;
595
 
596
  if (sym_index == 0)
597
    return -1;
598
 
599
  switch (sdata->version)
600
    {
601
    case BFD_SYM_VERSION_3_5:
602
    case BFD_SYM_VERSION_3_4:
603
      return -1;
604
 
605
    case BFD_SYM_VERSION_3_3:
606
      entry_size = 46;
607
      parser = bfd_sym_parse_modules_table_entry_v33;
608
      break;
609
 
610
    case BFD_SYM_VERSION_3_2:
611
    case BFD_SYM_VERSION_3_1:
612
    default:
613
      return -1;
614
    }
615
  if (parser == NULL)
616
    return -1;
617
 
618
  offset = compute_offset (sdata->header.dshb_mte.dti_first_page,
619
                           sdata->header.dshb_page_size,
620
                           entry_size, sym_index);
621
 
622
  if (bfd_seek (abfd, offset, SEEK_SET) < 0)
623
    return -1;
624
  if (bfd_bread (buf, entry_size, abfd) != entry_size)
625
    return -1;
626
 
627
  (*parser) (buf, entry_size, entry);
628
 
629
  return 0;
630
}
631
 
632
int
633
bfd_sym_fetch_file_references_table_entry (bfd *abfd,
634
                                           bfd_sym_file_references_table_entry *entry,
635
                                           unsigned long sym_index)
636
{
637
  void (*parser) (unsigned char *, size_t, bfd_sym_file_references_table_entry *);
638
  unsigned long offset;
639
  unsigned long entry_size = 0;
640
  unsigned char buf[8];
641
  bfd_sym_data_struct *sdata = NULL;
642
 
643
  parser = NULL;
644
  BFD_ASSERT (bfd_sym_valid (abfd));
645
  sdata = abfd->tdata.sym_data;
646
 
647
  if (sym_index == 0)
648
    return -1;
649
 
650
  switch (sdata->version)
651
    {
652
    case BFD_SYM_VERSION_3_3:
653
    case BFD_SYM_VERSION_3_2:
654
      entry_size = 10;
655
      parser = bfd_sym_parse_file_references_table_entry_v32;
656
      break;
657
 
658
    case BFD_SYM_VERSION_3_5:
659
    case BFD_SYM_VERSION_3_4:
660
    case BFD_SYM_VERSION_3_1:
661
    default:
662
      break;
663
    }
664
 
665
  if (parser == NULL)
666
    return -1;
667
 
668
  offset = compute_offset (sdata->header.dshb_frte.dti_first_page,
669
                           sdata->header.dshb_page_size,
670
                           entry_size, sym_index);
671
 
672
  if (bfd_seek (abfd, offset, SEEK_SET) < 0)
673
    return -1;
674
  if (bfd_bread (buf, entry_size, abfd) != entry_size)
675
    return -1;
676
 
677
  (*parser) (buf, entry_size, entry);
678
 
679
  return 0;
680
}
681
 
682
int
683
bfd_sym_fetch_contained_modules_table_entry (bfd *abfd,
684
                                             bfd_sym_contained_modules_table_entry *entry,
685
                                             unsigned long sym_index)
686
{
687
  void (*parser) (unsigned char *, size_t, bfd_sym_contained_modules_table_entry *);
688
  unsigned long offset;
689
  unsigned long entry_size = 0;
690
  unsigned char buf[6];
691
  bfd_sym_data_struct *sdata = NULL;
692
 
693
  parser = NULL;
694
  BFD_ASSERT (bfd_sym_valid (abfd));
695
  sdata = abfd->tdata.sym_data;
696
 
697
  if (sym_index == 0)
698
    return -1;
699
 
700
  switch (sdata->version)
701
    {
702
    case BFD_SYM_VERSION_3_3:
703
    case BFD_SYM_VERSION_3_2:
704
      entry_size = 6;
705
      parser = bfd_sym_parse_contained_modules_table_entry_v32;
706
      break;
707
 
708
    case BFD_SYM_VERSION_3_5:
709
    case BFD_SYM_VERSION_3_4:
710
    case BFD_SYM_VERSION_3_1:
711
    default:
712
      break;
713
    }
714
 
715
  if (parser == NULL)
716
    return -1;
717
 
718
  offset = compute_offset (sdata->header.dshb_cmte.dti_first_page,
719
                           sdata->header.dshb_page_size,
720
                           entry_size, sym_index);
721
 
722
  if (bfd_seek (abfd, offset, SEEK_SET) < 0)
723
    return -1;
724
  if (bfd_bread (buf, entry_size, abfd) != entry_size)
725
    return -1;
726
 
727
  (*parser) (buf, entry_size, entry);
728
 
729
  return 0;
730
}
731
 
732
int
733
bfd_sym_fetch_contained_variables_table_entry (bfd *abfd,
734
                                               bfd_sym_contained_variables_table_entry *entry,
735
                                               unsigned long sym_index)
736
{
737
  void (*parser) (unsigned char *, size_t, bfd_sym_contained_variables_table_entry *);
738
  unsigned long offset;
739
  unsigned long entry_size = 0;
740
  unsigned char buf[26];
741
  bfd_sym_data_struct *sdata = NULL;
742
 
743
  parser = NULL;
744
  BFD_ASSERT (bfd_sym_valid (abfd));
745
  sdata = abfd->tdata.sym_data;
746
 
747
  if (sym_index == 0)
748
    return -1;
749
 
750
  switch (sdata->version)
751
    {
752
    case BFD_SYM_VERSION_3_3:
753
    case BFD_SYM_VERSION_3_2:
754
      entry_size = 26;
755
      parser = bfd_sym_parse_contained_variables_table_entry_v32;
756
      break;
757
 
758
    case BFD_SYM_VERSION_3_5:
759
    case BFD_SYM_VERSION_3_4:
760
    case BFD_SYM_VERSION_3_1:
761
    default:
762
      break;
763
    }
764
 
765
  if (parser == NULL)
766
    return -1;
767
 
768
  offset = compute_offset (sdata->header.dshb_cvte.dti_first_page,
769
                           sdata->header.dshb_page_size,
770
                           entry_size, sym_index);
771
 
772
  if (bfd_seek (abfd, offset, SEEK_SET) < 0)
773
    return -1;
774
  if (bfd_bread (buf, entry_size, abfd) != entry_size)
775
    return -1;
776
 
777
  (*parser) (buf, entry_size, entry);
778
 
779
  return 0;
780
}
781
 
782
int
783
bfd_sym_fetch_contained_statements_table_entry (bfd *abfd,
784
                                                bfd_sym_contained_statements_table_entry *entry,
785
                                                unsigned long sym_index)
786
{
787
  void (*parser) (unsigned char *, size_t, bfd_sym_contained_statements_table_entry *);
788
  unsigned long offset;
789
  unsigned long entry_size = 0;
790
  unsigned char buf[8];
791
  bfd_sym_data_struct *sdata = NULL;
792
 
793
  parser = NULL;
794
  BFD_ASSERT (bfd_sym_valid (abfd));
795
  sdata = abfd->tdata.sym_data;
796
 
797
  if (sym_index == 0)
798
    return -1;
799
 
800
  switch (sdata->version)
801
    {
802
    case BFD_SYM_VERSION_3_3:
803
    case BFD_SYM_VERSION_3_2:
804
      entry_size = 8;
805
      parser = bfd_sym_parse_contained_statements_table_entry_v32;
806
      break;
807
 
808
    case BFD_SYM_VERSION_3_5:
809
    case BFD_SYM_VERSION_3_4:
810
    case BFD_SYM_VERSION_3_1:
811
    default:
812
      break;
813
    }
814
 
815
  if (parser == NULL)
816
    return -1;
817
 
818
  offset = compute_offset (sdata->header.dshb_csnte.dti_first_page,
819
                           sdata->header.dshb_page_size,
820
                           entry_size, sym_index);
821
 
822
  if (bfd_seek (abfd, offset, SEEK_SET) < 0)
823
    return -1;
824
  if (bfd_bread (buf, entry_size, abfd) != entry_size)
825
    return -1;
826
 
827
  (*parser) (buf, entry_size, entry);
828
 
829
  return 0;
830
}
831
 
832
int
833
bfd_sym_fetch_contained_labels_table_entry (bfd *abfd,
834
                                            bfd_sym_contained_labels_table_entry *entry,
835
                                            unsigned long sym_index)
836
{
837
  void (*parser) (unsigned char *, size_t, bfd_sym_contained_labels_table_entry *);
838
  unsigned long offset;
839
  unsigned long entry_size = 0;
840
  unsigned char buf[12];
841
  bfd_sym_data_struct *sdata = NULL;
842
 
843
  parser = NULL;
844
  BFD_ASSERT (bfd_sym_valid (abfd));
845
  sdata = abfd->tdata.sym_data;
846
 
847
  if (sym_index == 0)
848
    return -1;
849
 
850
  switch (sdata->version)
851
    {
852
    case BFD_SYM_VERSION_3_3:
853
    case BFD_SYM_VERSION_3_2:
854
      entry_size = 12;
855
      parser = bfd_sym_parse_contained_labels_table_entry_v32;
856
      break;
857
 
858
    case BFD_SYM_VERSION_3_5:
859
    case BFD_SYM_VERSION_3_4:
860
    case BFD_SYM_VERSION_3_1:
861
    default:
862
      break;
863
    }
864
 
865
  if (parser == NULL)
866
    return -1;
867
 
868
  offset = compute_offset (sdata->header.dshb_clte.dti_first_page,
869
                           sdata->header.dshb_page_size,
870
                           entry_size, sym_index);
871
 
872
  if (bfd_seek (abfd, offset, SEEK_SET) < 0)
873
    return -1;
874
  if (bfd_bread (buf, entry_size, abfd) != entry_size)
875
    return -1;
876
 
877
  (*parser) (buf, entry_size, entry);
878
 
879
  return 0;
880
}
881
 
882
int
883
bfd_sym_fetch_contained_types_table_entry (bfd *abfd,
884
                                           bfd_sym_contained_types_table_entry *entry,
885
                                           unsigned long sym_index)
886
{
887
  void (*parser) (unsigned char *, size_t, bfd_sym_contained_types_table_entry *);
888
  unsigned long offset;
889
  unsigned long entry_size = 0;
890
  unsigned char buf[0];
891
  bfd_sym_data_struct *sdata = NULL;
892
 
893
  parser = NULL;
894
  BFD_ASSERT (bfd_sym_valid (abfd));
895
  sdata = abfd->tdata.sym_data;
896
 
897
  if (sym_index == 0)
898
    return -1;
899
 
900
  switch (sdata->version)
901
    {
902
    case BFD_SYM_VERSION_3_3:
903
    case BFD_SYM_VERSION_3_2:
904
      entry_size = 0;
905
      parser = NULL;
906
      break;
907
 
908
    case BFD_SYM_VERSION_3_5:
909
    case BFD_SYM_VERSION_3_4:
910
    case BFD_SYM_VERSION_3_1:
911
    default:
912
      break;
913
    }
914
 
915
  if (parser == NULL)
916
    return -1;
917
 
918
  offset = compute_offset (sdata->header.dshb_ctte.dti_first_page,
919
                           sdata->header.dshb_page_size,
920
                           entry_size, sym_index);
921
 
922
  if (bfd_seek (abfd, offset, SEEK_SET) < 0)
923
    return -1;
924
  if (bfd_bread (buf, entry_size, abfd) != entry_size)
925
    return -1;
926
 
927
  (*parser) (buf, entry_size, entry);
928
 
929
  return 0;
930
}
931
 
932
int
933
bfd_sym_fetch_file_references_index_table_entry (bfd *abfd,
934
                                                 bfd_sym_file_references_index_table_entry *entry,
935
                                                 unsigned long sym_index)
936
{
937
  void (*parser) (unsigned char *, size_t, bfd_sym_file_references_index_table_entry *);
938
  unsigned long offset;
939
  unsigned long entry_size = 0;
940
  unsigned char buf[0];
941
  bfd_sym_data_struct *sdata = NULL;
942
 
943
  parser = NULL;
944
  BFD_ASSERT (bfd_sym_valid (abfd));
945
  sdata = abfd->tdata.sym_data;
946
 
947
  if (sym_index == 0)
948
    return -1;
949
 
950
  switch (sdata->version)
951
    {
952
    case BFD_SYM_VERSION_3_3:
953
    case BFD_SYM_VERSION_3_2:
954
      entry_size = 0;
955
      parser = NULL;
956
      break;
957
 
958
    case BFD_SYM_VERSION_3_5:
959
    case BFD_SYM_VERSION_3_4:
960
    case BFD_SYM_VERSION_3_1:
961
    default:
962
      break;
963
    }
964
 
965
  if (parser == NULL)
966
    return -1;
967
 
968
  offset = compute_offset (sdata->header.dshb_fite.dti_first_page,
969
                           sdata->header.dshb_page_size,
970
                           entry_size, sym_index);
971
 
972
  if (bfd_seek (abfd, offset, SEEK_SET) < 0)
973
    return -1;
974
  if (bfd_bread (buf, entry_size, abfd) != entry_size)
975
    return -1;
976
 
977
  (*parser) (buf, entry_size, entry);
978
 
979
  return 0;
980
}
981
 
982
int
983
bfd_sym_fetch_constant_pool_entry (bfd *abfd,
984
                                   bfd_sym_constant_pool_entry *entry,
985
                                   unsigned long sym_index)
986
{
987
  void (*parser) (unsigned char *, size_t, bfd_sym_constant_pool_entry *);
988
  unsigned long offset;
989
  unsigned long entry_size = 0;
990
  unsigned char buf[0];
991
  bfd_sym_data_struct *sdata = NULL;
992
 
993
  parser = NULL;
994
  BFD_ASSERT (bfd_sym_valid (abfd));
995
  sdata = abfd->tdata.sym_data;
996
 
997
  if (sym_index == 0)
998
    return -1;
999
 
1000
  switch (sdata->version)
1001
    {
1002
    case BFD_SYM_VERSION_3_3:
1003
    case BFD_SYM_VERSION_3_2:
1004
      entry_size = 0;
1005
      parser = NULL;
1006
      break;
1007
 
1008
    case BFD_SYM_VERSION_3_5:
1009
    case BFD_SYM_VERSION_3_4:
1010
    case BFD_SYM_VERSION_3_1:
1011
    default:
1012
      break;
1013
    }
1014
 
1015
  if (parser == NULL)
1016
    return -1;
1017
 
1018
  offset = compute_offset (sdata->header.dshb_fite.dti_first_page,
1019
                           sdata->header.dshb_page_size,
1020
                           entry_size, sym_index);
1021
 
1022
  if (bfd_seek (abfd, offset, SEEK_SET) < 0)
1023
    return -1;
1024
  if (bfd_bread (buf, entry_size, abfd) != entry_size)
1025
    return -1;
1026
 
1027
  (*parser) (buf, entry_size, entry);
1028
 
1029
  return 0;
1030
}
1031
 
1032
int
1033
bfd_sym_fetch_type_table_entry (bfd *abfd,
1034
                                bfd_sym_type_table_entry *entry,
1035
                                unsigned long sym_index)
1036
{
1037
  void (*parser) (unsigned char *, size_t, bfd_sym_type_table_entry *);
1038
  unsigned long offset;
1039
  unsigned long entry_size = 0;
1040
  unsigned char buf[4];
1041
  bfd_sym_data_struct *sdata = NULL;
1042
 
1043
  parser = NULL;
1044
  BFD_ASSERT (bfd_sym_valid (abfd));
1045
  sdata = abfd->tdata.sym_data;
1046
 
1047
  switch (sdata->version)
1048
    {
1049
    case BFD_SYM_VERSION_3_3:
1050
    case BFD_SYM_VERSION_3_2:
1051
      entry_size = 4;
1052
      parser = bfd_sym_parse_type_table_entry_v32;
1053
      break;
1054
 
1055
    case BFD_SYM_VERSION_3_5:
1056
    case BFD_SYM_VERSION_3_4:
1057
    case BFD_SYM_VERSION_3_1:
1058
    default:
1059
      break;
1060
    }
1061
 
1062
  if (parser == NULL)
1063
    return -1;
1064
 
1065
  offset = compute_offset (sdata->header.dshb_tte.dti_first_page,
1066
                           sdata->header.dshb_page_size,
1067
                           entry_size, sym_index);
1068
 
1069
  if (bfd_seek (abfd, offset, SEEK_SET) < 0)
1070
    return -1;
1071
  if (bfd_bread (buf, entry_size, abfd) != entry_size)
1072
    return -1;
1073
 
1074
  (*parser) (buf, entry_size, entry);
1075
 
1076
  return 0;
1077
}
1078
 
1079
int
1080
bfd_sym_fetch_type_information_table_entry (bfd *abfd,
1081
                                            bfd_sym_type_information_table_entry *entry,
1082
                                            unsigned long offset)
1083
{
1084
  unsigned char buf[4];
1085
  bfd_sym_data_struct *sdata = NULL;
1086
 
1087
  BFD_ASSERT (bfd_sym_valid (abfd));
1088
  sdata = abfd->tdata.sym_data;
1089
 
1090
  if (offset == 0)
1091
    return -1;
1092
 
1093
  if (bfd_seek (abfd, offset, SEEK_SET) < 0)
1094
    return -1;
1095
 
1096
  if (bfd_bread (buf, 4, abfd) != 4)
1097
    return -1;
1098
  entry->nte_index = bfd_getb32 (buf);
1099
 
1100
  if (bfd_bread (buf, 2, abfd) != 2)
1101
    return -1;
1102
  entry->physical_size = bfd_getb16 (buf);
1103
 
1104
  if (entry->physical_size & 0x8000)
1105
    {
1106
      if (bfd_bread (buf, 4, abfd) != 4)
1107
        return -1;
1108
      entry->physical_size &= 0x7fff;
1109
      entry->logical_size = bfd_getb32 (buf);
1110
      entry->offset = offset + 10;
1111
    }
1112
  else
1113
    {
1114
      if (bfd_bread (buf, 2, abfd) != 2)
1115
        return -1;
1116
      entry->physical_size &= 0x7fff;
1117
      entry->logical_size = bfd_getb16 (buf);
1118
      entry->offset = offset + 8;
1119
    }
1120
 
1121
  return 0;
1122
}
1123
 
1124
int
1125
bfd_sym_fetch_type_table_information (bfd *abfd,
1126
                                      bfd_sym_type_information_table_entry *entry,
1127
                                      unsigned long sym_index)
1128
{
1129
  bfd_sym_type_table_entry tindex;
1130
  bfd_sym_data_struct *sdata = NULL;
1131
 
1132
  BFD_ASSERT (bfd_sym_valid (abfd));
1133
  sdata = abfd->tdata.sym_data;
1134
 
1135
  if (sdata->header.dshb_tte.dti_object_count <= 99)
1136
    return -1;
1137
  if (sym_index < 100)
1138
    return -1;
1139
 
1140
  if (bfd_sym_fetch_type_table_entry (abfd, &tindex, sym_index - 100) < 0)
1141
    return -1;
1142
  if (bfd_sym_fetch_type_information_table_entry (abfd, entry, tindex) < 0)
1143
    return -1;
1144
 
1145
  return 0;
1146
}
1147
 
1148
const unsigned char *
1149
bfd_sym_symbol_name (bfd *abfd, unsigned long sym_index)
1150
{
1151
  bfd_sym_data_struct *sdata = NULL;
1152
 
1153
  BFD_ASSERT (bfd_sym_valid (abfd));
1154
  sdata = abfd->tdata.sym_data;
1155
 
1156
  if (sym_index == 0)
1157
    return (const unsigned char *) "";
1158
 
1159
  sym_index *= 2;
1160
  if ((sym_index / sdata->header.dshb_page_size)
1161
      > sdata->header.dshb_nte.dti_page_count)
1162
    return (const unsigned char *) "\09[INVALID]";
1163
 
1164
  return (const unsigned char *) sdata->name_table + sym_index;
1165
}
1166
 
1167
const unsigned char *
1168
bfd_sym_module_name (bfd *abfd, unsigned long sym_index)
1169
{
1170
  bfd_sym_modules_table_entry entry;
1171
 
1172
  if (bfd_sym_fetch_modules_table_entry (abfd, &entry, sym_index) < 0)
1173
    return (const unsigned char *) "\09[INVALID]";
1174
 
1175
  return bfd_sym_symbol_name (abfd, entry.mte_nte_index);
1176
}
1177
 
1178
const char *
1179
bfd_sym_unparse_storage_kind (enum bfd_sym_storage_kind kind)
1180
{
1181
  switch (kind)
1182
    {
1183
    case BFD_SYM_STORAGE_KIND_LOCAL: return "LOCAL";
1184
    case BFD_SYM_STORAGE_KIND_VALUE: return "VALUE";
1185
    case BFD_SYM_STORAGE_KIND_REFERENCE: return "REFERENCE";
1186
    case BFD_SYM_STORAGE_KIND_WITH: return "WITH";
1187
    default: return "[UNKNOWN]";
1188
    }
1189
}
1190
 
1191
const char *
1192
bfd_sym_unparse_storage_class (enum bfd_sym_storage_class kind)
1193
{
1194
  switch (kind)
1195
    {
1196
    case BFD_SYM_STORAGE_CLASS_REGISTER: return "REGISTER";
1197
    case BFD_SYM_STORAGE_CLASS_GLOBAL: return "GLOBAL";
1198
    case BFD_SYM_STORAGE_CLASS_FRAME_RELATIVE: return "FRAME_RELATIVE";
1199
    case BFD_SYM_STORAGE_CLASS_STACK_RELATIVE: return "STACK_RELATIVE";
1200
    case BFD_SYM_STORAGE_CLASS_ABSOLUTE: return "ABSOLUTE";
1201
    case BFD_SYM_STORAGE_CLASS_CONSTANT: return "CONSTANT";
1202
    case BFD_SYM_STORAGE_CLASS_RESOURCE: return "RESOURCE";
1203
    case BFD_SYM_STORAGE_CLASS_BIGCONSTANT: return "BIGCONSTANT";
1204
    default: return "[UNKNOWN]";
1205
    }
1206
}
1207
 
1208
const char *
1209
bfd_sym_unparse_module_kind (enum bfd_sym_module_kind kind)
1210
{
1211
  switch (kind)
1212
    {
1213
    case BFD_SYM_MODULE_KIND_NONE: return "NONE";
1214
    case BFD_SYM_MODULE_KIND_PROGRAM: return "PROGRAM";
1215
    case BFD_SYM_MODULE_KIND_UNIT: return "UNIT";
1216
    case BFD_SYM_MODULE_KIND_PROCEDURE: return "PROCEDURE";
1217
    case BFD_SYM_MODULE_KIND_FUNCTION: return "FUNCTION";
1218
    case BFD_SYM_MODULE_KIND_DATA: return "DATA";
1219
    case BFD_SYM_MODULE_KIND_BLOCK: return "BLOCK";
1220
    default: return "[UNKNOWN]";
1221
    }
1222
}
1223
 
1224
const char *
1225
bfd_sym_unparse_symbol_scope (enum bfd_sym_symbol_scope scope)
1226
{
1227
  switch (scope)
1228
    {
1229
    case BFD_SYM_SYMBOL_SCOPE_LOCAL: return "LOCAL";
1230
    case BFD_SYM_SYMBOL_SCOPE_GLOBAL: return "GLOBAL";
1231
    default:
1232
      return "[UNKNOWN]";
1233
    }
1234
}
1235
 
1236
void
1237
bfd_sym_print_file_reference (bfd *abfd,
1238
                              FILE *f,
1239
                              bfd_sym_file_reference *entry)
1240
{
1241
  bfd_sym_file_references_table_entry frtentry;
1242
  int ret;
1243
 
1244
  ret = bfd_sym_fetch_file_references_table_entry (abfd, &frtentry,
1245
                                                   entry->fref_frte_index);
1246
  fprintf (f, "FILE ");
1247
 
1248
  if ((ret < 0) || (frtentry.generic.type != BFD_SYM_FILE_NAME_INDEX))
1249
    fprintf (f, "[INVALID]");
1250
  else
1251
    fprintf (f, "\"%.*s\"",
1252
             bfd_sym_symbol_name (abfd, frtentry.filename.nte_index)[0],
1253
             &bfd_sym_symbol_name (abfd, frtentry.filename.nte_index)[1]);
1254
 
1255
  fprintf (f, " (FRTE %lu)", entry->fref_frte_index);
1256
}
1257
 
1258
void
1259
bfd_sym_print_resources_table_entry (bfd *abfd,
1260
                                     FILE *f,
1261
                                     bfd_sym_resources_table_entry *entry)
1262
{
1263
  fprintf (f, " \"%.*s\" (NTE %lu), type \"%.4s\", num %u, size %lu, MTE %lu -- %lu",
1264
           bfd_sym_symbol_name (abfd, entry->rte_nte_index)[0],
1265
           &bfd_sym_symbol_name (abfd, entry->rte_nte_index)[1],
1266
           entry->rte_nte_index, entry->rte_res_type, entry->rte_res_number,
1267
           entry->rte_res_size, entry->rte_mte_first, entry->rte_mte_last);
1268
}
1269
 
1270
void
1271
bfd_sym_print_modules_table_entry (bfd *abfd,
1272
                                   FILE *f,
1273
                                   bfd_sym_modules_table_entry *entry)
1274
{
1275
  fprintf (f, "\"%.*s\" (NTE %lu)",
1276
           bfd_sym_symbol_name (abfd, entry->mte_nte_index)[0],
1277
           &bfd_sym_symbol_name (abfd, entry->mte_nte_index)[1],
1278
           entry->mte_nte_index);
1279
 
1280
  fprintf (f, "\n            ");
1281
 
1282
  bfd_sym_print_file_reference (abfd, f, &entry->mte_imp_fref);
1283
  fprintf (f, " range %lu -- %lu",
1284
           entry->mte_imp_fref.fref_offset, entry->mte_imp_end);
1285
 
1286
  fprintf (f, "\n            ");
1287
 
1288
  fprintf (f, "kind %s", bfd_sym_unparse_module_kind (entry->mte_kind));
1289
  fprintf (f, ", scope %s", bfd_sym_unparse_symbol_scope (entry->mte_scope));
1290
 
1291
  fprintf (f, ", RTE %lu, offset %lu, size %lu",
1292
           entry->mte_rte_index, entry->mte_res_offset, entry->mte_size);
1293
 
1294
  fprintf (f, "\n            ");
1295
 
1296
  fprintf (f, "CMTE %lu, CVTE %lu, CLTE %lu, CTTE %lu, CSNTE1 %lu, CSNTE2 %lu",
1297
           entry->mte_cmte_index, entry->mte_cvte_index,
1298
           entry->mte_clte_index, entry->mte_ctte_index,
1299
           entry->mte_csnte_idx_1, entry->mte_csnte_idx_2);
1300
 
1301
  if (entry->mte_parent != 0)
1302
    fprintf (f, ", parent %lu", entry->mte_parent);
1303
  else
1304
    fprintf (f, ", no parent");
1305
 
1306
  if (entry->mte_cmte_index != 0)
1307
    fprintf (f, ", child %lu", entry->mte_cmte_index);
1308
  else
1309
    fprintf (f, ", no child");
1310
}
1311
 
1312
void
1313
bfd_sym_print_file_references_table_entry (bfd *abfd,
1314
                                           FILE *f,
1315
                                           bfd_sym_file_references_table_entry *entry)
1316
{
1317
  switch (entry->generic.type)
1318
    {
1319
    case BFD_SYM_FILE_NAME_INDEX:
1320
      fprintf (f, "FILE \"%.*s\" (NTE %lu), modtime ",
1321
               bfd_sym_symbol_name (abfd, entry->filename.nte_index)[0],
1322
               &bfd_sym_symbol_name (abfd, entry->filename.nte_index)[1],
1323
               entry->filename.nte_index);
1324
 
1325
      fprintf (f, "[UNIMPLEMENTED]");
1326
      /* printModDate (entry->filename.mod_date); */
1327
      fprintf (f, " (0x%lx)", entry->filename.mod_date);
1328
      break;
1329
 
1330
    case BFD_SYM_END_OF_LIST:
1331
      fprintf (f, "END");
1332
      break;
1333
 
1334
    default:
1335
      fprintf (f, "\"%.*s\" (MTE %lu), offset %lu",
1336
               bfd_sym_module_name (abfd, entry->entry.mte_index)[0],
1337
               &bfd_sym_module_name (abfd, entry->entry.mte_index)[1],
1338
               entry->entry.mte_index,
1339
               entry->entry.file_offset);
1340
      break;
1341
    }
1342
}
1343
 
1344
void
1345
bfd_sym_print_contained_modules_table_entry (bfd *abfd,
1346
                                             FILE *f,
1347
                                             bfd_sym_contained_modules_table_entry *entry)
1348
{
1349
  switch (entry->generic.type)
1350
    {
1351
    case BFD_SYM_END_OF_LIST:
1352
      fprintf (f, "END");
1353
      break;
1354
 
1355
    default:
1356
      fprintf (f, "\"%.*s\" (MTE %lu, NTE %lu)",
1357
               bfd_sym_module_name (abfd, entry->entry.mte_index)[0],
1358
               &bfd_sym_module_name (abfd, entry->entry.mte_index)[1],
1359
               entry->entry.mte_index,
1360
               entry->entry.nte_index);
1361
      break;
1362
    }
1363
}
1364
 
1365
void
1366
bfd_sym_print_contained_variables_table_entry (bfd *abfd,
1367
                                               FILE *f,
1368
                                               bfd_sym_contained_variables_table_entry *entry)
1369
{
1370
  if (entry->generic.type == BFD_SYM_END_OF_LIST)
1371
    {
1372
      fprintf (f, "END");
1373
      return;
1374
    }
1375
 
1376
  if (entry->generic.type == BFD_SYM_SOURCE_FILE_CHANGE)
1377
    {
1378
      bfd_sym_print_file_reference (abfd, f, &entry->file.fref);
1379
      fprintf (f, " offset %lu", entry->file.fref.fref_offset);
1380
      return;
1381
    }
1382
 
1383
  fprintf (f, "\"%.*s\" (NTE %lu)",
1384
           bfd_sym_symbol_name (abfd, entry->entry.nte_index)[0],
1385
           &bfd_sym_symbol_name (abfd, entry->entry.nte_index)[1],
1386
           entry->entry.nte_index);
1387
 
1388
  fprintf (f, ", TTE %lu", entry->entry.tte_index);
1389
  fprintf (f, ", offset %lu", entry->entry.file_delta);
1390
  fprintf (f, ", scope %s", bfd_sym_unparse_symbol_scope (entry->entry.scope));
1391
 
1392
  if (entry->entry.la_size == BFD_SYM_CVTE_SCA)
1393
    fprintf (f, ", latype %s, laclass %s, laoffset %lu",
1394
             bfd_sym_unparse_storage_kind (entry->entry.address.scstruct.sca_kind),
1395
             bfd_sym_unparse_storage_class (entry->entry.address.scstruct.sca_class),
1396
             entry->entry.address.scstruct.sca_offset);
1397
  else if (entry->entry.la_size <= BFD_SYM_CVTE_LA_MAX_SIZE)
1398
    {
1399
      unsigned long i;
1400
 
1401
      fprintf (f, ", la [");
1402
      for (i = 0; i < entry->entry.la_size; i++)
1403
        fprintf (f, "0x%02x ", entry->entry.address.lastruct.la[i]);
1404
      fprintf (f, "]");
1405
    }
1406
  else if (entry->entry.la_size == BFD_SYM_CVTE_BIG_LA)
1407
    fprintf (f, ", bigla %lu, biglakind %u",
1408
             entry->entry.address.biglastruct.big_la,
1409
             entry->entry.address.biglastruct.big_la_kind);
1410
 
1411
  else
1412
    fprintf (f, ", la [INVALID]");
1413
}
1414
 
1415
void
1416
bfd_sym_print_contained_statements_table_entry (bfd *abfd,
1417
                                                FILE *f,
1418
                                                bfd_sym_contained_statements_table_entry *entry)
1419
{
1420
  if (entry->generic.type == BFD_SYM_END_OF_LIST)
1421
    {
1422
      fprintf (f, "END");
1423
      return;
1424
    }
1425
 
1426
  if (entry->generic.type == BFD_SYM_SOURCE_FILE_CHANGE)
1427
    {
1428
      bfd_sym_print_file_reference (abfd, f, &entry->file.fref);
1429
      fprintf (f, " offset %lu", entry->file.fref.fref_offset);
1430
      return;
1431
    }
1432
 
1433
  fprintf (f, "\"%.*s\" (MTE %lu), offset %lu, delta %lu",
1434
           bfd_sym_module_name (abfd, entry->entry.mte_index)[0],
1435
           &bfd_sym_module_name (abfd, entry->entry.mte_index)[1],
1436
           entry->entry.mte_index,
1437
           entry->entry.mte_offset,
1438
           entry->entry.file_delta);
1439
}
1440
 
1441
void
1442
bfd_sym_print_contained_labels_table_entry (bfd *abfd,
1443
                                            FILE *f,
1444
                                            bfd_sym_contained_labels_table_entry *entry)
1445
{
1446
  if (entry->generic.type == BFD_SYM_END_OF_LIST)
1447
    {
1448
      fprintf (f, "END");
1449
      return;
1450
    }
1451
 
1452
  if (entry->generic.type == BFD_SYM_SOURCE_FILE_CHANGE)
1453
    {
1454
      bfd_sym_print_file_reference (abfd, f, &entry->file.fref);
1455
      fprintf (f, " offset %lu", entry->file.fref.fref_offset);
1456
      return;
1457
    }
1458
 
1459
  fprintf (f, "\"%.*s\" (MTE %lu), offset %lu, delta %lu, scope %s",
1460
           bfd_sym_module_name (abfd, entry->entry.mte_index)[0],
1461
           &bfd_sym_module_name (abfd, entry->entry.mte_index)[1],
1462
           entry->entry.mte_index,
1463
           entry->entry.mte_offset,
1464
           entry->entry.file_delta,
1465
           bfd_sym_unparse_symbol_scope (entry->entry.scope));
1466
}
1467
 
1468
void
1469
bfd_sym_print_contained_types_table_entry (bfd *abfd ATTRIBUTE_UNUSED,
1470
                                           FILE *f,
1471
                                           bfd_sym_contained_types_table_entry *entry ATTRIBUTE_UNUSED)
1472
{
1473
  fprintf (f, "[UNIMPLEMENTED]");
1474
}
1475
 
1476
const char *
1477
bfd_sym_type_operator_name (unsigned char num)
1478
{
1479
  switch (num)
1480
    {
1481
    case 1: return "TTE";
1482
    case 2: return "PointerTo";
1483
    case 3: return "ScalarOf";
1484
    case 4: return "ConstantOf";
1485
    case 5: return "EnumerationOf";
1486
    case 6: return "VectorOf";
1487
    case 7: return "RecordOf";
1488
    case 8: return "UnionOf";
1489
    case 9: return "SubRangeOf";
1490
    case 10: return "SetOf";
1491
    case 11: return "NamedTypeOf";
1492
    case 12: return "ProcOf";
1493
    case 13: return "ValueOf";
1494
    case 14: return "ArrayOf";
1495
    default: return "[UNKNOWN OPERATOR]";
1496
    }
1497
}
1498
 
1499
const char *
1500
bfd_sym_type_basic_name (unsigned char num)
1501
{
1502
  switch (num)
1503
    {
1504
    case 0: return "void";
1505
    case 1: return "pascal string";
1506
    case 2: return "unsigned long";
1507
    case 3: return "signed long";
1508
    case 4: return "extended (10 bytes)";
1509
    case 5: return "pascal boolean (1 byte)";
1510
    case 6: return "unsigned byte";
1511
    case 7: return "signed byte";
1512
    case 8: return "character (1 byte)";
1513
    case 9: return "wide character (2 bytes)";
1514
    case 10: return "unsigned short";
1515
    case 11: return "signed short";
1516
    case 12: return "singled";
1517
    case 13: return "double";
1518
    case 14: return "extended (12 bytes)";
1519
    case 15: return "computational (8 bytes)";
1520
    case 16: return "c string";
1521
    case 17: return "as-is string";
1522
    default: return "[UNKNOWN BASIC TYPE]";
1523
    }
1524
}
1525
 
1526
int
1527
bfd_sym_fetch_long (unsigned char *buf,
1528
                    unsigned long len,
1529
                    unsigned long offset,
1530
                    unsigned long *offsetptr,
1531
                    long *value)
1532
{
1533
  int ret;
1534
 
1535
  if (offset >= len)
1536
    {
1537
      *value = 0;
1538
      offset += 0;
1539
      ret = -1;
1540
    }
1541
  else if (! (buf[offset] & 0x80))
1542
    {
1543
      *value = buf[offset];
1544
      offset += 1;
1545
      ret = 0;
1546
    }
1547
  else if (buf[offset] == 0xc0)
1548
    {
1549
      if ((offset + 5) > len)
1550
        {
1551
          *value = 0;
1552
          offset = len;
1553
          ret = -1;
1554
        }
1555
      else
1556
        {
1557
          *value = bfd_getb32 (buf + offset + 1);
1558
          offset += 5;
1559
          ret = 0;
1560
        }
1561
    }
1562
  else if ((buf[offset] & 0xc0) == 0xc0)
1563
    {
1564
      *value =  -(buf[offset] & 0x3f);
1565
      offset += 1;
1566
      ret = 0;
1567
    }
1568
  else if ((buf[offset] & 0xc0) == 0x80)
1569
    {
1570
      if ((offset + 2) > len)
1571
        {
1572
          *value = 0;
1573
          offset = len;
1574
          ret = -1;
1575
        }
1576
      else
1577
        {
1578
          *value = bfd_getb16 (buf + offset) & 0x3fff;
1579
          offset += 2;
1580
          ret = 0;
1581
        }
1582
    }
1583
  else
1584
    abort ();
1585
 
1586
  if (offsetptr != NULL)
1587
    *offsetptr = offset;
1588
 
1589
  return ret;
1590
}
1591
 
1592
void
1593
bfd_sym_print_type_information (bfd *abfd,
1594
                                FILE *f,
1595
                                unsigned char *buf,
1596
                                unsigned long len,
1597
                                unsigned long offset,
1598
                                unsigned long *offsetptr)
1599
{
1600
  unsigned int type;
1601
 
1602
  if (offset >= len)
1603
    {
1604
      fprintf (f, "[NULL]");
1605
 
1606
      if (offsetptr != NULL)
1607
        *offsetptr = offset;
1608
      return;
1609
  }
1610
 
1611
  type = buf[offset];
1612
  offset++;
1613
 
1614
  if (! (type & 0x80))
1615
    {
1616
      fprintf (f, "[%s] (0x%x)", bfd_sym_type_basic_name (type & 0x7f), type);
1617
 
1618
      if (offsetptr != NULL)
1619
        *offsetptr = offset;
1620
      return;
1621
    }
1622
 
1623
  if (type & 0x40)
1624
    fprintf (f, "[packed ");
1625
  else
1626
    fprintf (f, "[");
1627
 
1628
  switch (type & 0x3f)
1629
    {
1630
    case 1:
1631
      {
1632
        long value;
1633
        bfd_sym_type_information_table_entry tinfo;
1634
 
1635
        bfd_sym_fetch_long (buf, len, offset, &offset, &value);
1636
        if (value <= 0)
1637
          fprintf (f, "[INVALID]");
1638
        else
1639
          {
1640
            if (bfd_sym_fetch_type_table_information (abfd, &tinfo, value) < 0)
1641
              fprintf (f, "[INVALID]");
1642
            else
1643
              fprintf (f, "\"%.*s\"",
1644
                       bfd_sym_symbol_name (abfd, tinfo.nte_index)[0],
1645
                       &bfd_sym_symbol_name (abfd, tinfo.nte_index)[1]);
1646
          }
1647
        fprintf (f, " (TTE %lu)", (unsigned long) value);
1648
        break;
1649
      }
1650
 
1651
    case 2:
1652
      fprintf (f, "pointer (0x%x) to ", type);
1653
      bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1654
      break;
1655
 
1656
    case 3:
1657
      {
1658
        long value;
1659
 
1660
        fprintf (f, "scalar (0x%x) of ", type);
1661
        bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1662
        bfd_sym_fetch_long (buf, len, offset, &offset, &value);
1663
        fprintf (f, " (%lu)", (unsigned long) value);
1664
        break;
1665
      }
1666
 
1667
    case 5:
1668
      {
1669
        long lower, upper, nelem;
1670
        int i;
1671
 
1672
        fprintf (f, "enumeration (0x%x) of ", type);
1673
        bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1674
        bfd_sym_fetch_long (buf, len, offset, &offset, &lower);
1675
        bfd_sym_fetch_long (buf, len, offset, &offset, &upper);
1676
        bfd_sym_fetch_long (buf, len, offset, &offset, &nelem);
1677
        fprintf (f, " from %lu to %lu with %lu elements: ",
1678
                 (unsigned long) lower, (unsigned long) upper,
1679
                 (unsigned long) nelem);
1680
 
1681
        for (i = 0; i < nelem; i++)
1682
          {
1683
            fprintf (f, "\n                    ");
1684
            bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1685
          }
1686
        break;
1687
      }
1688
 
1689
    case 6:
1690
      fprintf (f, "vector (0x%x)", type);
1691
      fprintf (f, "\n                index ");
1692
      bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1693
      fprintf (f, "\n                target ");
1694
      bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1695
      break;
1696
 
1697
    case 7:
1698
    case 8:
1699
      {
1700
        long nrec, eloff, i;
1701
 
1702
        if ((type & 0x3f) == 7)
1703
          fprintf (f, "record (0x%x) of ", type);
1704
        else
1705
          fprintf (f, "union (0x%x) of ", type);
1706
 
1707
        bfd_sym_fetch_long (buf, len, offset, &offset, &nrec);
1708
        fprintf (f, "%lu elements: ", (unsigned long) nrec);
1709
 
1710
        for (i = 0; i < nrec; i++)
1711
          {
1712
            bfd_sym_fetch_long (buf, len, offset, &offset, &eloff);
1713
            fprintf (f, "\n                ");
1714
            fprintf (f, "offset %lu: ", (unsigned long) eloff);
1715
            bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1716
          }
1717
        break;
1718
      }
1719
 
1720
    case 9:
1721
      fprintf (f, "subrange (0x%x) of ", type);
1722
      bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1723
      fprintf (f, " lower ");
1724
      bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1725
      fprintf (f, " upper ");
1726
      bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1727
      break;
1728
 
1729
  case 11:
1730
    {
1731
      long value;
1732
 
1733
      fprintf (f, "named type (0x%x) ", type);
1734
      bfd_sym_fetch_long (buf, len, offset, &offset, &value);
1735
      if (value <= 0)
1736
        fprintf (f, "[INVALID]");
1737
      else
1738
        fprintf (f, "\"%.*s\"",
1739
                 bfd_sym_symbol_name (abfd, value)[0],
1740
                 &bfd_sym_symbol_name (abfd, value)[1]);
1741
 
1742
      fprintf (f, " (NTE %lu) with type ", (unsigned long) value);
1743
      bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1744
      break;
1745
    }
1746
 
1747
  default:
1748
    fprintf (f, "%s (0x%x)", bfd_sym_type_operator_name (type), type);
1749
    break;
1750
    }
1751
 
1752
  if (type == (0x40 | 0x6))
1753
    {
1754
      /* Vector.  */
1755
      long n, width, m;
1756
      long l;
1757
      long i;
1758
 
1759
      bfd_sym_fetch_long (buf, len, offset, &offset, &n);
1760
      bfd_sym_fetch_long (buf, len, offset, &offset, &width);
1761
      bfd_sym_fetch_long (buf, len, offset, &offset, &m);
1762
      /* fprintf (f, "\n                "); */
1763
      fprintf (f, " N %ld, width %ld, M %ld, ", n, width, m);
1764
      for (i = 0; i < m; i++)
1765
        {
1766
          bfd_sym_fetch_long (buf, len, offset, &offset, &l);
1767
          if (i != 0)
1768
            fprintf (f, " ");
1769
          fprintf (f, "%ld", l);
1770
        }
1771
    }
1772
  else  if (type & 0x40)
1773
    {
1774
      /* Other packed type.  */
1775
      long msb, lsb;
1776
 
1777
      bfd_sym_fetch_long (buf, len, offset, &offset, &msb);
1778
      bfd_sym_fetch_long (buf, len, offset, &offset, &lsb);
1779
      /* fprintf (f, "\n                "); */
1780
      fprintf (f, " msb %ld, lsb %ld", msb, lsb);
1781
    }
1782
 
1783
  fprintf (f, "]");
1784
 
1785
  if (offsetptr != NULL)
1786
    *offsetptr = offset;
1787
}
1788
 
1789
void
1790
bfd_sym_print_type_information_table_entry (bfd *abfd,
1791
                                            FILE *f,
1792
                                            bfd_sym_type_information_table_entry *entry)
1793
{
1794
  unsigned char *buf;
1795
  unsigned long offset;
1796
  unsigned int i;
1797
 
1798
  fprintf (f, "\"%.*s\" (NTE %lu), %lu bytes at %lu, logical size %lu",
1799
           bfd_sym_symbol_name (abfd, entry->nte_index)[0],
1800
           &bfd_sym_symbol_name (abfd, entry->nte_index)[1],
1801
           entry->nte_index,
1802
           entry->physical_size, entry->offset, entry->logical_size);
1803
 
1804
  fprintf (f, "\n            ");
1805
 
1806
  buf = alloca (entry->physical_size);
1807
  if (buf == NULL)
1808
    {
1809
      fprintf (f, "[ERROR]\n");
1810
      return;
1811
    }
1812
  if (bfd_seek (abfd, entry->offset, SEEK_SET) < 0)
1813
    {
1814
      fprintf (f, "[ERROR]\n");
1815
      return;
1816
    }
1817
  if (bfd_bread (buf, entry->physical_size, abfd) != entry->physical_size)
1818
    {
1819
      fprintf (f, "[ERROR]\n");
1820
      return;
1821
    }
1822
 
1823
  fprintf (f, "[");
1824
  for (i = 0; i < entry->physical_size; i++)
1825
    {
1826
      if (i == 0)
1827
        fprintf (f, "0x%02x", buf[i]);
1828
      else
1829
        fprintf (f, " 0x%02x", buf[i]);
1830
    }
1831
 
1832
  fprintf (f, "]");
1833
  fprintf (f, "\n            ");
1834
 
1835
  bfd_sym_print_type_information (abfd, f, buf, entry->physical_size, 0, &offset);
1836
 
1837
  if (offset != entry->physical_size)
1838
    fprintf (f, "\n            [parser used %lu bytes instead of %lu]", offset, entry->physical_size);
1839
}
1840
 
1841
void
1842
bfd_sym_print_file_references_index_table_entry (bfd *abfd ATTRIBUTE_UNUSED,
1843
                                                 FILE *f,
1844
                                                 bfd_sym_file_references_index_table_entry *entry ATTRIBUTE_UNUSED)
1845
{
1846
  fprintf (f, "[UNIMPLEMENTED]");
1847
}
1848
 
1849
void
1850
bfd_sym_print_constant_pool_entry (bfd *abfd ATTRIBUTE_UNUSED,
1851
                                   FILE *f,
1852
                                   bfd_sym_constant_pool_entry *entry ATTRIBUTE_UNUSED)
1853
{
1854
  fprintf (f, "[UNIMPLEMENTED]");
1855
}
1856
 
1857
unsigned char *
1858
bfd_sym_display_name_table_entry (bfd *abfd,
1859
                                  FILE *f,
1860
                                  unsigned char *entry)
1861
{
1862
  unsigned long sym_index;
1863
  unsigned long offset;
1864
  bfd_sym_data_struct *sdata = NULL;
1865
 
1866
  BFD_ASSERT (bfd_sym_valid (abfd));
1867
  sdata = abfd->tdata.sym_data;
1868
  sym_index = (entry - sdata->name_table) / 2;
1869
 
1870
  if (sdata->version >= BFD_SYM_VERSION_3_4 && entry[0] == 255 && entry[1] == 0)
1871
    {
1872
      unsigned short length = bfd_getb16 (entry + 2);
1873
      fprintf (f, "[%8lu] \"%.*s\"\n", sym_index, length, entry + 4);
1874
      offset = 2 + length + 1;
1875
    }
1876
  else
1877
    {
1878
      if (! (entry[0] == 0 || (entry[0] == 1 && entry[1] == '\0')))
1879
        fprintf (f, "[%8lu] \"%.*s\"\n", sym_index, entry[0], entry + 1);
1880
 
1881
      if (sdata->version >= BFD_SYM_VERSION_3_4)
1882
        offset = entry[0] + 2;
1883
      else
1884
        offset = entry[0] + 1;
1885
    }
1886
 
1887
  return (entry + offset + (offset % 2));
1888
}
1889
 
1890
void
1891
bfd_sym_display_name_table (bfd *abfd, FILE *f)
1892
{
1893
  unsigned long name_table_len;
1894
  unsigned char *name_table, *name_table_end, *cur;
1895
  bfd_sym_data_struct *sdata = NULL;
1896
 
1897
  BFD_ASSERT (bfd_sym_valid (abfd));
1898
  sdata = abfd->tdata.sym_data;
1899
 
1900
  name_table_len = sdata->header.dshb_nte.dti_page_count * sdata->header.dshb_page_size;
1901
  name_table = sdata->name_table;
1902
  name_table_end = name_table + name_table_len;
1903
 
1904
  fprintf (f, "name table (NTE) contains %lu bytes:\n\n", name_table_len);
1905
 
1906
  cur = name_table;
1907
  for (;;)
1908
    {
1909
      cur = bfd_sym_display_name_table_entry (abfd, f, cur);
1910
      if (cur >= name_table_end)
1911
        break;
1912
    }
1913
}
1914
 
1915
void
1916
bfd_sym_display_resources_table (bfd *abfd, FILE *f)
1917
{
1918
  unsigned long i;
1919
  bfd_sym_resources_table_entry entry;
1920
  bfd_sym_data_struct *sdata = NULL;
1921
 
1922
  BFD_ASSERT (bfd_sym_valid (abfd));
1923
  sdata = abfd->tdata.sym_data;
1924
 
1925
  fprintf (f, "resource table (RTE) contains %lu objects:\n\n",
1926
           sdata->header.dshb_rte.dti_object_count);
1927
 
1928
  for (i = 1; i <= sdata->header.dshb_rte.dti_object_count; i++)
1929
    {
1930
      if (bfd_sym_fetch_resources_table_entry (abfd, &entry, i) < 0)
1931
        fprintf (f, " [%8lu] [INVALID]\n", i);
1932
      else
1933
        {
1934
          fprintf (f, " [%8lu] ", i);
1935
          bfd_sym_print_resources_table_entry (abfd, f, &entry);
1936
          fprintf (f, "\n");
1937
        }
1938
    }
1939
}
1940
 
1941
void
1942
bfd_sym_display_modules_table (bfd *abfd, FILE *f)
1943
{
1944
  unsigned long i;
1945
  bfd_sym_modules_table_entry entry;
1946
  bfd_sym_data_struct *sdata = NULL;
1947
 
1948
  BFD_ASSERT (bfd_sym_valid (abfd));
1949
  sdata = abfd->tdata.sym_data;
1950
 
1951
  fprintf (f, "module table (MTE) contains %lu objects:\n\n",
1952
           sdata->header.dshb_mte.dti_object_count);
1953
 
1954
  for (i = 1; i <= sdata->header.dshb_mte.dti_object_count; i++)
1955
    {
1956
      if (bfd_sym_fetch_modules_table_entry (abfd, &entry, i) < 0)
1957
        fprintf (f, " [%8lu] [INVALID]\n", i);
1958
      else
1959
        {
1960
          fprintf (f, " [%8lu] ", i);
1961
          bfd_sym_print_modules_table_entry (abfd, f, &entry);
1962
          fprintf (f, "\n");
1963
        }
1964
    }
1965
}
1966
 
1967
void
1968
bfd_sym_display_file_references_table (bfd *abfd, FILE *f)
1969
{
1970
  unsigned long i;
1971
  bfd_sym_file_references_table_entry entry;
1972
  bfd_sym_data_struct *sdata = NULL;
1973
 
1974
  BFD_ASSERT (bfd_sym_valid (abfd));
1975
  sdata = abfd->tdata.sym_data;
1976
 
1977
  fprintf (f, "file reference table (FRTE) contains %lu objects:\n\n",
1978
           sdata->header.dshb_frte.dti_object_count);
1979
 
1980
  for (i = 1; i <= sdata->header.dshb_frte.dti_object_count; i++)
1981
    {
1982
      if (bfd_sym_fetch_file_references_table_entry (abfd, &entry, i) < 0)
1983
        fprintf (f, " [%8lu] [INVALID]\n", i);
1984
      else
1985
        {
1986
          fprintf (f, " [%8lu] ", i);
1987
          bfd_sym_print_file_references_table_entry (abfd, f, &entry);
1988
          fprintf (f, "\n");
1989
        }
1990
    }
1991
}
1992
 
1993
void
1994
bfd_sym_display_contained_modules_table (bfd *abfd, FILE *f)
1995
{
1996
  unsigned long i;
1997
  bfd_sym_contained_modules_table_entry entry;
1998
  bfd_sym_data_struct *sdata = NULL;
1999
 
2000
  BFD_ASSERT (bfd_sym_valid (abfd));
2001
  sdata = abfd->tdata.sym_data;
2002
 
2003
  fprintf (f, "contained modules table (CMTE) contains %lu objects:\n\n",
2004
           sdata->header.dshb_cmte.dti_object_count);
2005
 
2006
  for (i = 1; i <= sdata->header.dshb_cmte.dti_object_count; i++)
2007
    {
2008
      if (bfd_sym_fetch_contained_modules_table_entry (abfd, &entry, i) < 0)
2009
        fprintf (f, " [%8lu] [INVALID]\n", i);
2010
      else
2011
        {
2012
          fprintf (f, " [%8lu] ", i);
2013
          bfd_sym_print_contained_modules_table_entry (abfd, f, &entry);
2014
          fprintf (f, "\n");
2015
        }
2016
    }
2017
}
2018
 
2019
void
2020
bfd_sym_display_contained_variables_table (bfd *abfd, FILE *f)
2021
{
2022
  unsigned long i;
2023
  bfd_sym_contained_variables_table_entry entry;
2024
  bfd_sym_data_struct *sdata = NULL;
2025
 
2026
  BFD_ASSERT (bfd_sym_valid (abfd));
2027
  sdata = abfd->tdata.sym_data;
2028
 
2029
  fprintf (f, "contained variables table (CVTE) contains %lu objects:\n\n",
2030
           sdata->header.dshb_cvte.dti_object_count);
2031
 
2032
  for (i = 1; i <= sdata->header.dshb_cvte.dti_object_count; i++)
2033
    {
2034
      if (bfd_sym_fetch_contained_variables_table_entry (abfd, &entry, i) < 0)
2035
        fprintf (f, " [%8lu] [INVALID]\n", i);
2036
      else
2037
        {
2038
          fprintf (f, " [%8lu] ", i);
2039
          bfd_sym_print_contained_variables_table_entry (abfd, f, &entry);
2040
          fprintf (f, "\n");
2041
        }
2042
    }
2043
 
2044
  fprintf (f, "\n");
2045
}
2046
 
2047
void
2048
bfd_sym_display_contained_statements_table (bfd *abfd, FILE *f)
2049
{
2050
  unsigned long i;
2051
  bfd_sym_contained_statements_table_entry entry;
2052
  bfd_sym_data_struct *sdata = NULL;
2053
 
2054
  BFD_ASSERT (bfd_sym_valid (abfd));
2055
  sdata = abfd->tdata.sym_data;
2056
 
2057
  fprintf (f, "contained statements table (CSNTE) contains %lu objects:\n\n",
2058
           sdata->header.dshb_csnte.dti_object_count);
2059
 
2060
  for (i = 1; i <= sdata->header.dshb_csnte.dti_object_count; i++)
2061
    {
2062
      if (bfd_sym_fetch_contained_statements_table_entry (abfd, &entry, i) < 0)
2063
        fprintf (f, " [%8lu] [INVALID]\n", i);
2064
      else
2065
        {
2066
          fprintf (f, " [%8lu] ", i);
2067
          bfd_sym_print_contained_statements_table_entry (abfd, f, &entry);
2068
          fprintf (f, "\n");
2069
        }
2070
    }
2071
}
2072
 
2073
void
2074
bfd_sym_display_contained_labels_table (bfd *abfd, FILE *f)
2075
{
2076
  unsigned long i;
2077
  bfd_sym_contained_labels_table_entry entry;
2078
  bfd_sym_data_struct *sdata = NULL;
2079
 
2080
  BFD_ASSERT (bfd_sym_valid (abfd));
2081
  sdata = abfd->tdata.sym_data;
2082
 
2083
  fprintf (f, "contained labels table (CLTE) contains %lu objects:\n\n",
2084
           sdata->header.dshb_clte.dti_object_count);
2085
 
2086
  for (i = 1; i <= sdata->header.dshb_clte.dti_object_count; i++)
2087
    {
2088
      if (bfd_sym_fetch_contained_labels_table_entry (abfd, &entry, i) < 0)
2089
        fprintf (f, " [%8lu] [INVALID]\n", i);
2090
      else
2091
        {
2092
          fprintf (f, " [%8lu] ", i);
2093
          bfd_sym_print_contained_labels_table_entry (abfd, f, &entry);
2094
          fprintf (f, "\n");
2095
        }
2096
    }
2097
}
2098
 
2099
void
2100
bfd_sym_display_contained_types_table (bfd *abfd, FILE *f)
2101
{
2102
  unsigned long i;
2103
  bfd_sym_contained_types_table_entry entry;
2104
  bfd_sym_data_struct *sdata = NULL;
2105
 
2106
  BFD_ASSERT (bfd_sym_valid (abfd));
2107
  sdata = abfd->tdata.sym_data;
2108
 
2109
  fprintf (f, "contained types table (CTTE) contains %lu objects:\n\n",
2110
           sdata->header.dshb_ctte.dti_object_count);
2111
 
2112
  for (i = 1; i <= sdata->header.dshb_ctte.dti_object_count; i++)
2113
    {
2114
      if (bfd_sym_fetch_contained_types_table_entry (abfd, &entry, i) < 0)
2115
        fprintf (f, " [%8lu] [INVALID]\n", i);
2116
      else
2117
        {
2118
          fprintf (f, " [%8lu] ", i);
2119
          bfd_sym_print_contained_types_table_entry (abfd, f, &entry);
2120
          fprintf (f, "\n");
2121
        }
2122
    }
2123
}
2124
 
2125
void
2126
bfd_sym_display_file_references_index_table (bfd *abfd, FILE *f)
2127
{
2128
  unsigned long i;
2129
  bfd_sym_file_references_index_table_entry entry;
2130
  bfd_sym_data_struct *sdata = NULL;
2131
 
2132
  BFD_ASSERT (bfd_sym_valid (abfd));
2133
  sdata = abfd->tdata.sym_data;
2134
 
2135
  fprintf (f, "file references index table (FITE) contains %lu objects:\n\n",
2136
           sdata->header.dshb_fite.dti_object_count);
2137
 
2138
  for (i = 1; i <= sdata->header.dshb_fite.dti_object_count; i++)
2139
    {
2140
      if (bfd_sym_fetch_file_references_index_table_entry (abfd, &entry, i) < 0)
2141
        fprintf (f, " [%8lu] [INVALID]\n", i);
2142
      else
2143
        {
2144
          fprintf (f, " [%8lu] ", i);
2145
          bfd_sym_print_file_references_index_table_entry (abfd, f, &entry);
2146
          fprintf (f, "\n");
2147
        }
2148
    }
2149
}
2150
 
2151
void
2152
bfd_sym_display_constant_pool (bfd *abfd, FILE *f)
2153
{
2154
  unsigned long i;
2155
  bfd_sym_constant_pool_entry entry;
2156
  bfd_sym_data_struct *sdata = NULL;
2157
 
2158
  BFD_ASSERT (bfd_sym_valid (abfd));
2159
  sdata = abfd->tdata.sym_data;
2160
 
2161
  fprintf (f, "constant pool (CONST) contains %lu objects:\n\n",
2162
           sdata->header.dshb_const.dti_object_count);
2163
 
2164
  for (i = 1; i <= sdata->header.dshb_const.dti_object_count; i++)
2165
    {
2166
      if (bfd_sym_fetch_constant_pool_entry (abfd, &entry, i) < 0)
2167
        fprintf (f, " [%8lu] [INVALID]\n", i);
2168
      else
2169
        {
2170
          fprintf (f, " [%8lu] ", i);
2171
          bfd_sym_print_constant_pool_entry (abfd, f, &entry);
2172
          fprintf (f, "\n");
2173
        }
2174
    }
2175
}
2176
 
2177
void
2178
bfd_sym_display_type_information_table (bfd *abfd, FILE *f)
2179
{
2180
  unsigned long i;
2181
  bfd_sym_type_table_entry sym_index;
2182
  bfd_sym_type_information_table_entry entry;
2183
  bfd_sym_data_struct *sdata = NULL;
2184
 
2185
  BFD_ASSERT (bfd_sym_valid (abfd));
2186
  sdata = abfd->tdata.sym_data;
2187
 
2188
  if (sdata->header.dshb_tte.dti_object_count > 99)
2189
    fprintf (f, "type table (TINFO) contains %lu objects:\n\n",
2190
             sdata->header.dshb_tte.dti_object_count - 99);
2191
  else
2192
    {
2193
      fprintf (f, "type table (TINFO) contains [INVALID] objects:\n\n");
2194
      return;
2195
    }
2196
 
2197
  for (i = 100; i <= sdata->header.dshb_tte.dti_object_count; i++)
2198
    {
2199
      if (bfd_sym_fetch_type_table_entry (abfd, &sym_index, i - 100) < 0)
2200
        fprintf (f, " [%8lu] [INVALID]\n", i);
2201
      else
2202
        {
2203
          fprintf (f, " [%8lu] (TINFO %lu) ", i, sym_index);
2204
 
2205
          if (bfd_sym_fetch_type_information_table_entry (abfd, &entry, sym_index) < 0)
2206
            fprintf (f, "[INVALID]");
2207
          else
2208
            bfd_sym_print_type_information_table_entry (abfd, f, &entry);
2209
 
2210
          fprintf (f, "\n");
2211
        }
2212
    }
2213
}
2214
 
2215
int
2216
bfd_sym_scan (bfd *abfd, bfd_sym_version version, bfd_sym_data_struct *mdata)
2217
{
2218
  asection *bfdsec;
2219
  const char *name = "symbols";
2220
 
2221
  mdata->name_table = 0;
2222
  mdata->sbfd = abfd;
2223
  mdata->version = version;
2224
 
2225
  bfd_seek (abfd, 0, SEEK_SET);
2226
  if (bfd_sym_read_header (abfd, &mdata->header, mdata->version) != 0)
2227
    return -1;
2228
 
2229
  mdata->name_table = bfd_sym_read_name_table (abfd, &mdata->header);
2230
  if (mdata->name_table == NULL)
2231
    return -1;
2232
 
2233
  bfdsec = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
2234
  if (bfdsec == NULL)
2235
    return -1;
2236
 
2237
  bfdsec->vma = 0;
2238
  bfdsec->lma = 0;
2239
  bfdsec->size = 0;
2240
  bfdsec->filepos = 0;
2241
  bfdsec->alignment_power = 0;
2242
 
2243
  abfd->tdata.sym_data = mdata;
2244
 
2245
  return 0;
2246
}
2247
 
2248
const bfd_target *
2249
bfd_sym_object_p (bfd *abfd)
2250
{
2251
  struct bfd_preserve preserve;
2252
  bfd_sym_version version = -1;
2253
 
2254
  preserve.marker = NULL;
2255
  bfd_seek (abfd, 0, SEEK_SET);
2256
  if (bfd_sym_read_version (abfd, &version) != 0)
2257
    goto wrong;
2258
 
2259
  preserve.marker = bfd_alloc (abfd, sizeof (bfd_sym_data_struct));
2260
  if (preserve.marker == NULL
2261
      || ! bfd_preserve_save (abfd, &preserve))
2262
    goto fail;
2263
 
2264
  if (bfd_sym_scan (abfd, version,
2265
                    (bfd_sym_data_struct *) preserve.marker) != 0)
2266
    goto wrong;
2267
 
2268
  bfd_preserve_finish (abfd, &preserve);
2269
  return abfd->xvec;
2270
 
2271
 wrong:
2272
  bfd_set_error (bfd_error_wrong_format);
2273
 
2274
 fail:
2275
  if (preserve.marker != NULL)
2276
    bfd_preserve_restore (abfd, &preserve);
2277
  return NULL;
2278
}
2279
 
2280
#define bfd_sym_make_empty_symbol _bfd_generic_make_empty_symbol
2281
 
2282
void
2283
bfd_sym_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, asymbol *symbol, symbol_info *ret)
2284
{
2285
  bfd_symbol_info (symbol, ret);
2286
}
2287
 
2288
long
2289
bfd_sym_get_symtab_upper_bound (bfd *abfd ATTRIBUTE_UNUSED)
2290
{
2291
  return 0;
2292
}
2293
 
2294
long
2295
bfd_sym_canonicalize_symtab (bfd *abfd ATTRIBUTE_UNUSED, asymbol **sym ATTRIBUTE_UNUSED)
2296
{
2297
  return 0;
2298
}
2299
 
2300
int
2301
bfd_sym_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
2302
                        struct bfd_link_info *info ATTRIBUTE_UNUSED)
2303
{
2304
  return 0;
2305
}
2306
 
2307
const bfd_target sym_vec =
2308
{
2309
  "sym",                        /* Name.  */
2310
  bfd_target_sym_flavour,       /* Flavour.  */
2311
  BFD_ENDIAN_BIG,               /* Byteorder.  */
2312
  BFD_ENDIAN_BIG,               /* Header byteorder.  */
2313
  (HAS_RELOC | EXEC_P |         /* Object flags.  */
2314
   HAS_LINENO | HAS_DEBUG |
2315
   HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
2316
  (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_DATA
2317
   | SEC_ROM | SEC_HAS_CONTENTS), /* Section_flags.  */
2318
  0,                             /* Symbol_leading_char.  */
2319
  ' ',                          /* AR_pad_char.  */
2320
  16,                           /* AR_max_namelen.  */
2321
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2322
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2323
  bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Data.  */
2324
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2325
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2326
  bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Hdrs.  */
2327
  {                             /* bfd_check_format.  */
2328
    _bfd_dummy_target,
2329
    bfd_sym_object_p,           /* bfd_check_format.  */
2330
    _bfd_dummy_target,
2331
    _bfd_dummy_target,
2332
  },
2333
  {                             /* bfd_set_format.  */
2334
    bfd_false,
2335
    bfd_sym_mkobject,
2336
    bfd_false,
2337
    bfd_false,
2338
  },
2339
  {                             /* bfd_write_contents.  */
2340
    bfd_false,
2341
    bfd_true,
2342
    bfd_false,
2343
    bfd_false,
2344
  },
2345
 
2346
  BFD_JUMP_TABLE_GENERIC (bfd_sym),
2347
  BFD_JUMP_TABLE_COPY (_bfd_generic),
2348
  BFD_JUMP_TABLE_CORE (_bfd_nocore),
2349
  BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
2350
  BFD_JUMP_TABLE_SYMBOLS (bfd_sym),
2351
  BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
2352
  BFD_JUMP_TABLE_WRITE (bfd_sym),
2353
  BFD_JUMP_TABLE_LINK (bfd_sym),
2354
  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2355
 
2356
  NULL,
2357
 
2358
  NULL
2359
};

powered by: WebSVN 2.1.0

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