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