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

Subversion Repositories openrisc_me

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

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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