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