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