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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [bfd/] [xsym.c] - Blame information for rev 818

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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