OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [xsym.c] - Blame information for rev 161

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 14 khays 
/* xSYM symbol-file support for BFD.
2 
   Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3 148 khays 
   2009, 2010, 2011 Free Software Foundation, Inc.
4 14 khays 
 
5 
   This file is part of BFD, the Binary File Descriptor library.
6 
 
7 
   This program is free software; you can redistribute it and/or modify
8 
   it under the terms of the GNU General Public License as published by
9 
   the Free Software Foundation; either version 3 of the License, or
10 
   (at your option) any later version.
11 
 
12 
   This program is distributed in the hope that it will be useful,
13 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 
   GNU General Public License for more details.
16 
 
17 
   You should have received a copy of the GNU General Public License
18 
   along with this program; if not, write to the Free Software
19 
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 
   MA 02110-1301, USA.  */
21 
 
22 
#include "alloca-conf.h"
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_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
35 
#define bfd_sym_find_inliner_info                   _bfd_nosymbols_find_inliner_info
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
39 
#define bfd_sym_set_arch_mach                       _bfd_generic_set_arch_mach
40 
#define bfd_sym_get_section_contents                _bfd_generic_get_section_contents
41 
#define bfd_sym_set_section_contents                _bfd_generic_set_section_contents
42 
#define bfd_sym_bfd_get_relocated_section_contents  bfd_generic_get_relocated_section_contents
43 
#define bfd_sym_bfd_relax_section                   bfd_generic_relax_section
44 
#define bfd_sym_bfd_gc_sections                     bfd_generic_gc_sections
45 161 khays 
#define bfd_sym_bfd_lookup_section_flags            bfd_generic_lookup_section_flags
46 14 khays 
#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
50 
#define bfd_sym_bfd_define_common_symbol            bfd_generic_define_common_symbol
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
55 
#define bfd_sym_bfd_copy_link_hash_symbol_type \
56 
  _bfd_generic_copy_link_hash_symbol_type
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
60 
 
61 
extern const bfd_target sym_vec;
62 
 
63 
static int
64 
pstrcmp (const char *as, const char *bs)
65 
{
66 
  const unsigned char *a = (const unsigned char *) as;
67 
  const unsigned char *b = (const unsigned char *) bs;
68 
  unsigned char clen;
69 
  int ret;
70 
 
71 
  clen = (a[0] > b[0]) ? b[0] : a[0];
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
81 
    return 1;
82 
}
83 
 
84 
static unsigned long
85 
compute_offset (unsigned long first_page,
86 
                unsigned long page_size,
87 
                unsigned long entry_size,
88 
                unsigned long sym_index)
89 
{
90 
  unsigned long entries_per_page = page_size / entry_size;
91 
  unsigned long page_number = first_page + (sym_index / entries_per_page);
92 
  unsigned long page_offset = (sym_index % entries_per_page) * entry_size;
93 
 
94 
  return (page_number * page_size) + page_offset;
95 
}
96 
 
97 
bfd_boolean
98 
bfd_sym_mkobject (bfd *abfd ATTRIBUTE_UNUSED)
99 
{
100 
  return 1;
101 
}
102 
 
103 
void
104 
bfd_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)
108 
{
109 
  return;
110 
}
111 
 
112 
bfd_boolean
113 
bfd_sym_valid (bfd *abfd)
114 
{
115 
  if (abfd == NULL || abfd->xvec == NULL)
116 
    return 0;
117 
 
118 
  return abfd->xvec == &sym_vec;
119 
}
120 
 
121 
unsigned char *
122 
bfd_sym_read_name_table (bfd *abfd, bfd_sym_header_block *dshb)
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;
128 
 
129 
  rstr = bfd_alloc (abfd, table_size);
130 
  if (rstr == NULL)
131 
    return rstr;
132 
 
133 
  bfd_seek (abfd, table_offset, SEEK_SET);
134 
  ret = bfd_bread (rstr, table_size, abfd);
135 
  if (ret < 0 || (unsigned long) ret != table_size)
136 
    {
137 
      bfd_release (abfd, rstr);
138 
      return NULL;
139 
    }
140 
 
141 
  return rstr;
142 
}
143 
 
144 
void
145 
bfd_sym_parse_file_reference_v32 (unsigned char *buf,
146 
                                  size_t len,
147 
                                  bfd_sym_file_reference *entry)
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 
 
155 
void
156 
bfd_sym_parse_disk_table_v32 (unsigned char *buf,
157 
                              size_t len,
158 
                              bfd_sym_table_info *table)
159 
{
160 
  BFD_ASSERT (len == 8);
161 
 
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);
165 
}
166 
 
167 
void
168 
bfd_sym_parse_header_v32 (unsigned char *buf,
169 
                          size_t len,
170 
                          bfd_sym_header_block *header)
171 
{
172 
  BFD_ASSERT (len == 154);
173 
 
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);
179 
 
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);
193 
 
194 
  memcpy (&header->dshb_file_creator, buf + 146, 4);
195 
  memcpy (&header->dshb_file_type, buf + 150, 4);
196 
}
197 
 
198 
int
199 
bfd_sym_read_header_v32 (bfd *abfd, bfd_sym_header_block *header)
200 
{
201 
  unsigned char buf[154];
202 
  long ret;
203 
 
204 
  ret = bfd_bread (buf, 154, abfd);
205 
  if (ret != 154)
206 
    return -1;
207 
 
208 
  bfd_sym_parse_header_v32 (buf, 154, header);
209 
 
210 
  return 0;
211 
}
212 
 
213 
int
214 
bfd_sym_read_header_v34 (bfd *abfd ATTRIBUTE_UNUSED,
215 
                         bfd_sym_header_block *header ATTRIBUTE_UNUSED)
216 
{
217 
  abort ();
218 
}
219 
 
220 
int
221 
bfd_sym_read_header (bfd *abfd,
222 
                     bfd_sym_header_block *header,
223 
                     bfd_sym_version version)
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:
235 
      return 0;
236 
    }
237 
}
238 
 
239 
int
240 
bfd_sym_read_version (bfd *abfd, bfd_sym_version *version)
241 
{
242 
  char version_string[32];
243 
  long ret;
244 
 
245 
  ret = bfd_bread (version_string, sizeof (version_string), abfd);
246 
  if (ret != sizeof (version_string))
247 
    return -1;
248 
 
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;
261 
 
262 
  return 0;
263 
}
264 
 
265 
void
266 
bfd_sym_display_table_summary (FILE *f,
267 
                               bfd_sym_table_info *dti,
268 
                               const char *name)
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 
 
277 
void
278 
bfd_sym_display_header (FILE *f, bfd_sym_header_block *dshb)
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);
290 
 
291 
  fprintf (f, "Table Name   First Page    Page Count   Object Count\n");
292 
  fprintf (f, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
293 
 
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");
307 
 
308 
  fprintf (f, "\n");
309 
}
310 
 
311 
void
312 
bfd_sym_parse_resources_table_entry_v32 (unsigned char *buf,
313 
                                         size_t len,
314 
                                         bfd_sym_resources_table_entry *entry)
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 
 
326 
void
327 
bfd_sym_parse_modules_table_entry_v33 (unsigned char *buf,
328 
                                       size_t len,
329 
                                       bfd_sym_modules_table_entry *entry)
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 
 
350 
void
351 
bfd_sym_parse_file_references_table_entry_v32 (unsigned char *buf,
352 
                                               size_t len,
353 
                                               bfd_sym_file_references_table_entry *entry)
354 
{
355 
  unsigned int type;
356 
 
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 
 
380 
void
381 
bfd_sym_parse_contained_modules_table_entry_v32 (unsigned char *buf,
382 
                                                 size_t len,
383 
                                                 bfd_sym_contained_modules_table_entry *entry)
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);
391 
 
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 
 
405 
void
406 
bfd_sym_parse_contained_variables_table_entry_v32 (unsigned char *buf,
407 
                                                   size_t len,
408 
                                                   bfd_sym_contained_variables_table_entry *entry)
409 
{
410 
  unsigned int type;
411 
 
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 
        {
443 
#if BFD_SYM_CVTE_SCA > 0
444 
          memcpy (&entry->entry.address.lastruct.la, buf + 10,
445 
                  BFD_SYM_CVTE_SCA);
446 
#endif
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 
 
457 
void
458 
bfd_sym_parse_contained_statements_table_entry_v32 (unsigned char *buf,
459 
                                                    size_t len,
460 
                                                    bfd_sym_contained_statements_table_entry *entry)
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);
468 
 
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 
 
488 
void
489 
bfd_sym_parse_contained_labels_table_entry_v32 (unsigned char *buf,
490 
                                                size_t len,
491 
                                                bfd_sym_contained_labels_table_entry *entry)
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);
499 
 
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 
 
521 
void
522 
bfd_sym_parse_type_table_entry_v32 (unsigned char *buf,
523 
                                    size_t len,
524 
                                    bfd_sym_type_table_entry *entry)
525 
{
526 
  BFD_ASSERT (len == 4);
527 
 
528 
  *entry = bfd_getb32 (buf);
529 
}
530 
 
531 
int
532 
bfd_sym_fetch_resources_table_entry (bfd *abfd,
533 
                                     bfd_sym_resources_table_entry *entry,
534 
                                     unsigned long sym_index)
535 
{
536 
  void (*parser) (unsigned char *, size_t, bfd_sym_resources_table_entry *);
537 
  unsigned long offset;
538 
  unsigned long entry_size;
539 
  unsigned char buf[18];
540 
  bfd_sym_data_struct *sdata = NULL;
541 
 
542 
  parser = NULL;
543 
  BFD_ASSERT (bfd_sym_valid (abfd));
544 
  sdata = abfd->tdata.sym_data;
545 
 
546 
  if (sym_index == 0)
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,
570 
                           entry_size, sym_index);
571 
 
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);
578 
 
579 
  return 0;
580 
}
581 
 
582 
int
583 
bfd_sym_fetch_modules_table_entry (bfd *abfd,
584 
                                   bfd_sym_modules_table_entry *entry,
585 
                                   unsigned long sym_index)
586 
{
587 
  void (*parser) (unsigned char *, size_t, bfd_sym_modules_table_entry *);
588 
  unsigned long offset;
589 
  unsigned long entry_size;
590 
  unsigned char buf[46];
591 
  bfd_sym_data_struct *sdata = NULL;
592 
 
593 
  parser = NULL;
594 
  BFD_ASSERT (bfd_sym_valid (abfd));
595 
  sdata = abfd->tdata.sym_data;
596 
 
597 
  if (sym_index == 0)
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,
621 
                           entry_size, sym_index);
622 
 
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);
629 
 
630 
  return 0;
631 
}
632 
 
633 
int
634 
bfd_sym_fetch_file_references_table_entry (bfd *abfd,
635 
                                           bfd_sym_file_references_table_entry *entry,
636 
                                           unsigned long sym_index)
637 
{
638 
  void (*parser) (unsigned char *, size_t, bfd_sym_file_references_table_entry *);
639 
  unsigned long offset;
640 
  unsigned long entry_size = 0;
641 
  unsigned char buf[8];
642 
  bfd_sym_data_struct *sdata = NULL;
643 
 
644 
  parser = NULL;
645 
  BFD_ASSERT (bfd_sym_valid (abfd));
646 
  sdata = abfd->tdata.sym_data;
647 
 
648 
  if (sym_index == 0)
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,
671 
                           entry_size, sym_index);
672 
 
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);
679 
 
680 
  return 0;
681 
}
682 
 
683 
int
684 
bfd_sym_fetch_contained_modules_table_entry (bfd *abfd,
685 
                                             bfd_sym_contained_modules_table_entry *entry,
686 
                                             unsigned long sym_index)
687 
{
688 
  void (*parser) (unsigned char *, size_t, bfd_sym_contained_modules_table_entry *);
689 
  unsigned long offset;
690 
  unsigned long entry_size = 0;
691 
  unsigned char buf[6];
692 
  bfd_sym_data_struct *sdata = NULL;
693 
 
694 
  parser = NULL;
695 
  BFD_ASSERT (bfd_sym_valid (abfd));
696 
  sdata = abfd->tdata.sym_data;
697 
 
698 
  if (sym_index == 0)
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,
721 
                           entry_size, sym_index);
722 
 
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);
729 
 
730 
  return 0;
731 
}
732 
 
733 
int
734 
bfd_sym_fetch_contained_variables_table_entry (bfd *abfd,
735 
                                               bfd_sym_contained_variables_table_entry *entry,
736 
                                               unsigned long sym_index)
737 
{
738 
  void (*parser) (unsigned char *, size_t, bfd_sym_contained_variables_table_entry *);
739 
  unsigned long offset;
740 
  unsigned long entry_size = 0;
741 
  unsigned char buf[26];
742 
  bfd_sym_data_struct *sdata = NULL;
743 
 
744 
  parser = NULL;
745 
  BFD_ASSERT (bfd_sym_valid (abfd));
746 
  sdata = abfd->tdata.sym_data;
747 
 
748 
  if (sym_index == 0)
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,
771 
                           entry_size, sym_index);
772 
 
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);
779 
 
780 
  return 0;
781 
}
782 
 
783 
int
784 
bfd_sym_fetch_contained_statements_table_entry (bfd *abfd,
785 
                                                bfd_sym_contained_statements_table_entry *entry,
786 
                                                unsigned long sym_index)
787 
{
788 
  void (*parser) (unsigned char *, size_t, bfd_sym_contained_statements_table_entry *);
789 
  unsigned long offset;
790 
  unsigned long entry_size = 0;
791 
  unsigned char buf[8];
792 
  bfd_sym_data_struct *sdata = NULL;
793 
 
794 
  parser = NULL;
795 
  BFD_ASSERT (bfd_sym_valid (abfd));
796 
  sdata = abfd->tdata.sym_data;
797 
 
798 
  if (sym_index == 0)
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,
821 
                           entry_size, sym_index);
822 
 
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);
829 
 
830 
  return 0;
831 
}
832 
 
833 
int
834 
bfd_sym_fetch_contained_labels_table_entry (bfd *abfd,
835 
                                            bfd_sym_contained_labels_table_entry *entry,
836 
                                            unsigned long sym_index)
837 
{
838 
  void (*parser) (unsigned char *, size_t, bfd_sym_contained_labels_table_entry *);
839 
  unsigned long offset;
840 
  unsigned long entry_size = 0;
841 
  unsigned char buf[12];
842 
  bfd_sym_data_struct *sdata = NULL;
843 
 
844 
  parser = NULL;
845 
  BFD_ASSERT (bfd_sym_valid (abfd));
846 
  sdata = abfd->tdata.sym_data;
847 
 
848 
  if (sym_index == 0)
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,
871 
                           entry_size, sym_index);
872 
 
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);
879 
 
880 
  return 0;
881 
}
882 
 
883 
int
884 
bfd_sym_fetch_contained_types_table_entry (bfd *abfd,
885 
                                           bfd_sym_contained_types_table_entry *entry,
886 
                                           unsigned long sym_index)
887 
{
888 
  void (*parser) (unsigned char *, size_t, bfd_sym_contained_types_table_entry *);
889 
  unsigned long offset;
890 
  unsigned long entry_size = 0;
891 
  unsigned char buf[0];
892 
  bfd_sym_data_struct *sdata = NULL;
893 
 
894 
  parser = NULL;
895 
  BFD_ASSERT (bfd_sym_valid (abfd));
896 
  sdata = abfd->tdata.sym_data;
897 
 
898 
  if (sym_index == 0)
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,
921 
                           entry_size, sym_index);
922 
 
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);
929 
 
930 
  return 0;
931 
}
932 
 
933 
int
934 
bfd_sym_fetch_file_references_index_table_entry (bfd *abfd,
935 
                                                 bfd_sym_file_references_index_table_entry *entry,
936 
                                                 unsigned long sym_index)
937 
{
938 
  void (*parser) (unsigned char *, size_t, bfd_sym_file_references_index_table_entry *);
939 
  unsigned long offset;
940 
  unsigned long entry_size = 0;
941 
  unsigned char buf[0];
942 
  bfd_sym_data_struct *sdata = NULL;
943 
 
944 
  parser = NULL;
945 
  BFD_ASSERT (bfd_sym_valid (abfd));
946 
  sdata = abfd->tdata.sym_data;
947 
 
948 
  if (sym_index == 0)
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,
971 
                           entry_size, sym_index);
972 
 
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);
979 
 
980 
  return 0;
981 
}
982 
 
983 
int
984 
bfd_sym_fetch_constant_pool_entry (bfd *abfd,
985 
                                   bfd_sym_constant_pool_entry *entry,
986 
                                   unsigned long sym_index)
987 
{
988 
  void (*parser) (unsigned char *, size_t, bfd_sym_constant_pool_entry *);
989 
  unsigned long offset;
990 
  unsigned long entry_size = 0;
991 
  unsigned char buf[0];
992 
  bfd_sym_data_struct *sdata = NULL;
993 
 
994 
  parser = NULL;
995 
  BFD_ASSERT (bfd_sym_valid (abfd));
996 
  sdata = abfd->tdata.sym_data;
997 
 
998 
  if (sym_index == 0)
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,
1021 
                           entry_size, sym_index);
1022 
 
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);
1029 
 
1030 
  return 0;
1031 
}
1032 
 
1033 
int
1034 
bfd_sym_fetch_type_table_entry (bfd *abfd,
1035 
                                bfd_sym_type_table_entry *entry,
1036 
                                unsigned long sym_index)
1037 
{
1038 
  void (*parser) (unsigned char *, size_t, bfd_sym_type_table_entry *);
1039 
  unsigned long offset;
1040 
  unsigned long entry_size = 0;
1041 
  unsigned char buf[4];
1042 
  bfd_sym_data_struct *sdata = NULL;
1043 
 
1044 
  parser = NULL;
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,
1068 
                           entry_size, sym_index);
1069 
 
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);
1076 
 
1077 
  return 0;
1078 
}
1079 
 
1080 
int
1081 
bfd_sym_fetch_type_information_table_entry (bfd *abfd,
1082 
                                            bfd_sym_type_information_table_entry *entry,
1083 
                                            unsigned long offset)
1084 
{
1085 
  unsigned char buf[4];
1086 
 
1087 
  BFD_ASSERT (bfd_sym_valid (abfd));
1088 
 
1089 
  if (offset == 0)
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);
1098 
 
1099 
  if (bfd_bread (buf, 2, abfd) != 2)
1100 
    return -1;
1101 
  entry->physical_size = bfd_getb16 (buf);
1102 
 
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 
 
1123 
int
1124 
bfd_sym_fetch_type_table_information (bfd *abfd,
1125 
                                      bfd_sym_type_information_table_entry *entry,
1126 
                                      unsigned long sym_index)
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;
1136 
  if (sym_index < 100)
1137 
    return -1;
1138 
 
1139 
  if (bfd_sym_fetch_type_table_entry (abfd, &tindex, sym_index - 100) < 0)
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 
 
1147 
const unsigned char *
1148 
bfd_sym_symbol_name (bfd *abfd, unsigned long sym_index)
1149 
{
1150 
  bfd_sym_data_struct *sdata = NULL;
1151 
 
1152 
  BFD_ASSERT (bfd_sym_valid (abfd));
1153 
  sdata = abfd->tdata.sym_data;
1154 
 
1155 
  if (sym_index == 0)
1156 
    return (const unsigned char *) "";
1157 
 
1158 
  sym_index *= 2;
1159 
  if ((sym_index / sdata->header.dshb_page_size)
1160 
      > sdata->header.dshb_nte.dti_page_count)
1161 
    return (const unsigned char *) "\09[INVALID]";
1162 
 
1163 
  return (const unsigned char *) sdata->name_table + sym_index;
1164 
}
1165 
 
1166 
const unsigned char *
1167 
bfd_sym_module_name (bfd *abfd, unsigned long sym_index)
1168 
{
1169 
  bfd_sym_modules_table_entry entry;
1170 
 
1171 
  if (bfd_sym_fetch_modules_table_entry (abfd, &entry, sym_index) < 0)
1172 
    return (const unsigned char *) "\09[INVALID]";
1173 
 
1174 
  return bfd_sym_symbol_name (abfd, entry.mte_nte_index);
1175 
}
1176 
 
1177 
const char *
1178 
bfd_sym_unparse_storage_kind (enum bfd_sym_storage_kind kind)
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 
 
1190 
const char *
1191 
bfd_sym_unparse_storage_class (enum bfd_sym_storage_class kind)
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 
 
1207 
const char *
1208 
bfd_sym_unparse_module_kind (enum bfd_sym_module_kind kind)
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 
 
1223 
const char *
1224 
bfd_sym_unparse_symbol_scope (enum bfd_sym_symbol_scope scope)
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 
 
1235 
void
1236 
bfd_sym_print_file_reference (bfd *abfd,
1237 
                              FILE *f,
1238 
                              bfd_sym_file_reference *entry)
1239 
{
1240 
  bfd_sym_file_references_table_entry frtentry;
1241 
  int ret;
1242 
 
1243 
  ret = bfd_sym_fetch_file_references_table_entry (abfd, &frtentry,
1244 
                                                   entry->fref_frte_index);
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 
 
1257 
void
1258 
bfd_sym_print_resources_table_entry (bfd *abfd,
1259 
                                     FILE *f,
1260 
                                     bfd_sym_resources_table_entry *entry)
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);
1267 
}
1268 
 
1269 
void
1270 
bfd_sym_print_modules_table_entry (bfd *abfd,
1271 
                                   FILE *f,
1272 
                                   bfd_sym_modules_table_entry *entry)
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);
1278 
 
1279 
  fprintf (f, "\n            ");
1280 
 
1281 
  bfd_sym_print_file_reference (abfd, f, &entry->mte_imp_fref);
1282 
  fprintf (f, " range %lu -- %lu",
1283 
           entry->mte_imp_fref.fref_offset, entry->mte_imp_end);
1284 
 
1285 
  fprintf (f, "\n            ");
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));
1289 
 
1290 
  fprintf (f, ", RTE %lu, offset %lu, size %lu",
1291 
           entry->mte_rte_index, entry->mte_res_offset, entry->mte_size);
1292 
 
1293 
  fprintf (f, "\n            ");
1294 
 
1295 
  fprintf (f, "CMTE %lu, CVTE %lu, CLTE %lu, CTTE %lu, CSNTE1 %lu, CSNTE2 %lu",
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);
1299 
 
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");
1309 
}
1310 
 
1311 
void
1312 
bfd_sym_print_file_references_table_entry (bfd *abfd,
1313 
                                           FILE *f,
1314 
                                           bfd_sym_file_references_table_entry *entry)
1315 
{
1316 
  switch (entry->generic.type)
1317 
    {
1318 
    case BFD_SYM_FILE_NAME_INDEX:
1319 
      fprintf (f, "FILE \"%.*s\" (NTE %lu), modtime ",
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 
 
1343 
void
1344 
bfd_sym_print_contained_modules_table_entry (bfd *abfd,
1345 
                                             FILE *f,
1346 
                                             bfd_sym_contained_modules_table_entry *entry)
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 
 
1364 
void
1365 
bfd_sym_print_contained_variables_table_entry (bfd *abfd,
1366 
                                               FILE *f,
1367 
                                               bfd_sym_contained_variables_table_entry *entry)
1368 
{
1369 
  if (entry->generic.type == BFD_SYM_END_OF_LIST)
1370 
    {
1371 
      fprintf (f, "END");
1372 
      return;
1373 
    }
1374 
 
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 
    }
1381 
 
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);
1386 
 
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",
1407 
             entry->entry.address.biglastruct.big_la,
1408 
             entry->entry.address.biglastruct.big_la_kind);
1409 
 
1410 
  else
1411 
    fprintf (f, ", la [INVALID]");
1412 
}
1413 
 
1414 
void
1415 
bfd_sym_print_contained_statements_table_entry (bfd *abfd,
1416 
                                                FILE *f,
1417 
                                                bfd_sym_contained_statements_table_entry *entry)
1418 
{
1419 
  if (entry->generic.type == BFD_SYM_END_OF_LIST)
1420 
    {
1421 
      fprintf (f, "END");
1422 
      return;
1423 
    }
1424 
 
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 
 
1440 
void
1441 
bfd_sym_print_contained_labels_table_entry (bfd *abfd,
1442 
                                            FILE *f,
1443 
                                            bfd_sym_contained_labels_table_entry *entry)
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 
 
1467 
void
1468 
bfd_sym_print_contained_types_table_entry (bfd *abfd ATTRIBUTE_UNUSED,
1469 
                                           FILE *f,
1470 
                                           bfd_sym_contained_types_table_entry *entry ATTRIBUTE_UNUSED)
1471 
{
1472 
  fprintf (f, "[UNIMPLEMENTED]");
1473 
}
1474 
 
1475 
const char *
1476 
bfd_sym_type_operator_name (unsigned char num)
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 
 
1498 
const char *
1499 
bfd_sym_type_basic_name (unsigned char num)
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 
 
1525 
int
1526 
bfd_sym_fetch_long (unsigned char *buf,
1527 
                    unsigned long len,
1528 
                    unsigned long offset,
1529 
                    unsigned long *offsetptr,
1530 
                    long *value)
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 
 
1591 
void
1592 
bfd_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)
1598 
{
1599 
  unsigned int type;
1600 
 
1601 
  if (offset >= len)
1602 
    {
1603 
      fprintf (f, "[NULL]");
1604 
 
1605 
      if (offsetptr != NULL)
1606 
        *offsetptr = offset;
1607 
      return;
1608 
  }
1609 
 
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 
 
1634 
        bfd_sym_fetch_long (buf, len, offset, &offset, &value);
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
1642 
              fprintf (f, "\"%.*s\"",
1643 
                       bfd_sym_symbol_name (abfd, tinfo.nte_index)[0],
1644 
                       &bfd_sym_symbol_name (abfd, tinfo.nte_index)[1]);
1645 
          }
1646 
        fprintf (f, " (TTE %lu)", (unsigned long) value);
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 
      {
1657 
        long value;
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);
1662 
        fprintf (f, " (%lu)", (unsigned long) value);
1663 
        break;
1664 
      }
1665 
 
1666 
    case 5:
1667 
      {
1668 
        long lower, upper, nelem;
1669 
        int i;
1670 
 
1671 
        fprintf (f, "enumeration (0x%x) of ", type);
1672 
        bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
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);
1676 
        fprintf (f, " from %lu to %lu with %lu elements: ",
1677 
                 (unsigned long) lower, (unsigned long) upper,
1678 
                 (unsigned long) nelem);
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);
1705 
 
1706 
        bfd_sym_fetch_long (buf, len, offset, &offset, &nrec);
1707 
        fprintf (f, "%lu elements: ", (unsigned long) nrec);
1708 
 
1709 
        for (i = 0; i < nrec; i++)
1710 
          {
1711 
            bfd_sym_fetch_long (buf, len, offset, &offset, &eloff);
1712 
            fprintf (f, "\n                ");
1713 
            fprintf (f, "offset %lu: ", (unsigned long) eloff);
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);
1733 
      bfd_sym_fetch_long (buf, len, offset, &offset, &value);
1734 
      if (value <= 0)
1735 
        fprintf (f, "[INVALID]");
1736 
      else
1737 
        fprintf (f, "\"%.*s\"",
1738 
                 bfd_sym_symbol_name (abfd, value)[0],
1739 
                 &bfd_sym_symbol_name (abfd, value)[1]);
1740 
 
1741 
      fprintf (f, " (NTE %lu) with type ", (unsigned long) value);
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 
    }
1750 
 
1751 
  if (type == (0x40 | 0x6))
1752 
    {
1753 
      /* Vector.  */
1754 
      long n, width, m;
1755 
      long l;
1756 
      long i;
1757 
 
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);
1761 
      /* fprintf (f, "\n                "); */
1762 
      fprintf (f, " N %ld, width %ld, M %ld, ", n, width, m);
1763 
      for (i = 0; i < m; i++)
1764 
        {
1765 
          bfd_sym_fetch_long (buf, len, offset, &offset, &l);
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 
 
1776 
      bfd_sym_fetch_long (buf, len, offset, &offset, &msb);
1777 
      bfd_sym_fetch_long (buf, len, offset, &offset, &lsb);
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 
 
1788 
void
1789 
bfd_sym_print_type_information_table_entry (bfd *abfd,
1790 
                                            FILE *f,
1791 
                                            bfd_sym_type_information_table_entry *entry)
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 
 
1803 
  fprintf (f, "\n            ");
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, "]");
1832 
  fprintf (f, "\n            ");
1833 
 
1834 
  bfd_sym_print_type_information (abfd, f, buf, entry->physical_size, 0, &offset);
1835 
 
1836 
  if (offset != entry->physical_size)
1837 
    fprintf (f, "\n            [parser used %lu bytes instead of %lu]", offset, entry->physical_size);
1838 
}
1839 
 
1840 
void
1841 
bfd_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)
1844 
{
1845 
  fprintf (f, "[UNIMPLEMENTED]");
1846 
}
1847 
 
1848 
void
1849 
bfd_sym_print_constant_pool_entry (bfd *abfd ATTRIBUTE_UNUSED,
1850 
                                   FILE *f,
1851 
                                   bfd_sym_constant_pool_entry *entry ATTRIBUTE_UNUSED)
1852 
{
1853 
  fprintf (f, "[UNIMPLEMENTED]");
1854 
}
1855 
 
1856 
unsigned char *
1857 
bfd_sym_display_name_table_entry (bfd *abfd,
1858 
                                  FILE *f,
1859 
                                  unsigned char *entry)
1860 
{
1861 
  unsigned long sym_index;
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;
1867 
  sym_index = (entry - sdata->name_table) / 2;
1868 
 
1869 
  if (sdata->version >= BFD_SYM_VERSION_3_4 && entry[0] == 255 && entry[1] == 0)
1870 
    {
1871 
      unsigned short length = bfd_getb16 (entry + 2);
1872 
      fprintf (f, "[%8lu] \"%.*s\"\n", sym_index, length, entry + 4);
1873 
      offset = 2 + length + 1;
1874 
    }
1875 
  else
1876 
    {
1877 
      if (! (entry[0] == 0 || (entry[0] == 1 && entry[1] == '\0')))
1878 
        fprintf (f, "[%8lu] \"%.*s\"\n", sym_index, entry[0], entry + 1);
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 
 
1889 
void
1890 
bfd_sym_display_name_table (bfd *abfd, FILE *f)
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;
1902 
 
1903 
  fprintf (f, "name table (NTE) contains %lu bytes:\n\n", name_table_len);
1904 
 
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 
 
1914 
void
1915 
bfd_sym_display_resources_table (bfd *abfd, FILE *f)
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);
1926 
 
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 
 
1940 
void
1941 
bfd_sym_display_modules_table (bfd *abfd, FILE *f)
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 
 
1966 
void
1967 
bfd_sym_display_file_references_table (bfd *abfd, FILE *f)
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 
 
1992 
void
1993 
bfd_sym_display_contained_modules_table (bfd *abfd, FILE *f)
1994 
{
1995 
  unsigned long i;
1996 
  bfd_sym_contained_modules_table_entry entry;
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);
2004 
 
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 
 
2018 
void
2019 
bfd_sym_display_contained_variables_table (bfd *abfd, FILE *f)
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);
2030 
 
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 
 
2046 
void
2047 
bfd_sym_display_contained_statements_table (bfd *abfd, FILE *f)
2048 
{
2049 
  unsigned long i;
2050 
  bfd_sym_contained_statements_table_entry entry;
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);
2058 
 
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 
 
2072 
void
2073 
bfd_sym_display_contained_labels_table (bfd *abfd, FILE *f)
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);
2084 
 
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 
 
2098 
void
2099 
bfd_sym_display_contained_types_table (bfd *abfd, FILE *f)
2100 
{
2101 
  unsigned long i;
2102 
  bfd_sym_contained_types_table_entry entry;
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);
2110 
 
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 
 
2124 
void
2125 
bfd_sym_display_file_references_index_table (bfd *abfd, FILE *f)
2126 
{
2127 
  unsigned long i;
2128 
  bfd_sym_file_references_index_table_entry entry;
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);
2136 
 
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 
 
2150 
void
2151 
bfd_sym_display_constant_pool (bfd *abfd, FILE *f)
2152 
{
2153 
  unsigned long i;
2154 
  bfd_sym_constant_pool_entry entry;
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);
2162 
 
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 
 
2176 
void
2177 
bfd_sym_display_type_information_table (bfd *abfd, FILE *f)
2178 
{
2179 
  unsigned long i;
2180 
  bfd_sym_type_table_entry sym_index;
2181 
  bfd_sym_type_information_table_entry entry;
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 
    }
2195 
 
2196 
  for (i = 100; i <= sdata->header.dshb_tte.dti_object_count; i++)
2197 
    {
2198 
      if (bfd_sym_fetch_type_table_entry (abfd, &sym_index, i - 100) < 0)
2199 
        fprintf (f, " [%8lu] [INVALID]\n", i);
2200 
      else
2201 
        {
2202 
          fprintf (f, " [%8lu] (TINFO %lu) ", i, sym_index);
2203 
 
2204 
          if (bfd_sym_fetch_type_information_table_entry (abfd, &entry, sym_index) < 0)
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 
 
2214 
int
2215 
bfd_sym_scan (bfd *abfd, bfd_sym_version version, bfd_sym_data_struct *mdata)
2216 
{
2217 
  asection *bfdsec;
2218 
  const char *name = "symbols";
2219 
 
2220 
  mdata->name_table = 0;
2221 
  mdata->sbfd = abfd;
2222 
  mdata->version = version;
2223 
 
2224 
  bfd_seek (abfd, 0, SEEK_SET);
2225 
  if (bfd_sym_read_header (abfd, &mdata->header, mdata->version) != 0)
2226 
    return -1;
2227 
 
2228 
  mdata->name_table = bfd_sym_read_name_table (abfd, &mdata->header);
2229 
  if (mdata->name_table == NULL)
2230 
    return -1;
2231 
 
2232 
  bfdsec = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
2233 
  if (bfdsec == NULL)
2234 
    return -1;
2235 
 
2236 
  bfdsec->vma = 0;
2237 
  bfdsec->lma = 0;
2238 
  bfdsec->size = 0;
2239 
  bfdsec->filepos = 0;
2240 
  bfdsec->alignment_power = 0;
2241 
 
2242 
  abfd->tdata.sym_data = mdata;
2243 
 
2244 
  return 0;
2245 
}
2246 
 
2247 
const bfd_target *
2248 
bfd_sym_object_p (bfd *abfd)
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);
2268 
  return abfd->xvec;
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;
2277 
}
2278 
 
2279 
#define bfd_sym_make_empty_symbol _bfd_generic_make_empty_symbol
2280 
 
2281 
void
2282 
bfd_sym_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, asymbol *symbol, symbol_info *ret)
2283 
{
2284 
  bfd_symbol_info (symbol, ret);
2285 
}
2286 
 
2287 
long
2288 
bfd_sym_get_symtab_upper_bound (bfd *abfd ATTRIBUTE_UNUSED)
2289 
{
2290 
  return 0;
2291 
}
2292 
 
2293 
long
2294 
bfd_sym_canonicalize_symtab (bfd *abfd ATTRIBUTE_UNUSED, asymbol **sym ATTRIBUTE_UNUSED)
2295 
{
2296 
  return 0;
2297 
}
2298 
 
2299 
int
2300 
bfd_sym_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
2301 
                        struct bfd_link_info *info ATTRIBUTE_UNUSED)
2302 
{
2303 
  return 0;
2304 
}
2305 
 
2306 
const bfd_target sym_vec =
2307 
{
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.  */
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
2316 
   | SEC_ROM | SEC_HAS_CONTENTS), /* Section_flags.  */
2317 
  0,                             /* Symbol_leading_char.  */
2318 
  ' ',                          /* AR_pad_char.  */
2319 
  16,                           /* AR_max_namelen.  */
2320 148 khays 
  0,                             /* match priority.  */
2321 14 khays 
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2322 
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2323 
  bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Data.  */
2324 
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2325 
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2326 
  bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Hdrs.  */
2327 
  {                             /* bfd_check_format.  */
2328 
    _bfd_dummy_target,
2329 
    bfd_sym_object_p,           /* bfd_check_format.  */
2330 
    _bfd_dummy_target,
2331 
    _bfd_dummy_target,
2332 
  },
2333 
  {                             /* bfd_set_format.  */
2334 
    bfd_false,
2335 
    bfd_sym_mkobject,
2336 
    bfd_false,
2337 
    bfd_false,
2338 
  },
2339 
  {                             /* bfd_write_contents.  */
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),
2351 
  BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
2352 
  BFD_JUMP_TABLE_WRITE (bfd_sym),
2353 
  BFD_JUMP_TABLE_LINK (bfd_sym),
2354 
  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2355 
 
2356 
  NULL,
2357 
 
2358 
  NULL
2359 
};

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.