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