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