bfd/
[platform/upstream/binutils.git] / bfd / xsym.c
1 /* 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 };