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