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