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 66

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

powered by: WebSVN 2.1.0

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