1 /* Read HP PA/Risc object files for GDB.
2 Copyright 1991, 1992, 1996 Free Software Foundation, Inc.
3 Written by Fred Fish at Cygnus Support.
5 This file is part of GDB.
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 2 of the License, or
10 (at your option) any later version.
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.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 #include "stabsread.h"
29 #include "gdb-stabs.h"
30 #include "complaints.h"
31 #include "gdb_string.h"
36 /* Various things we might complain about... */
39 som_symfile_init
PARAMS ((struct objfile
*));
42 som_new_init
PARAMS ((struct objfile
*));
45 som_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
48 som_symfile_finish
PARAMS ((struct objfile
*));
51 som_symtab_read
PARAMS ((bfd
*, struct objfile
*,
52 struct section_offsets
*));
54 static struct section_offsets
*
55 som_symfile_offsets
PARAMS ((struct objfile
*, CORE_ADDR
));
57 /* FIXME: These should really be in a common header somewhere */
60 hpread_build_psymtabs
PARAMS ((struct objfile
*, struct section_offsets
*, int));
63 hpread_symfile_finish
PARAMS ((struct objfile
*));
66 hpread_symfile_init
PARAMS ((struct objfile
*));
69 do_pxdb
PARAMS ((bfd
*));
75 som_symtab_read -- read the symbol table of a SOM file
79 void som_symtab_read (bfd *abfd, struct objfile *objfile,
80 struct section_offsets *section_offsets)
84 Given an open bfd, a base address to relocate symbols to, and a
85 flag that specifies whether or not this bfd is for an executable
86 or not (may be shared library for example), add all the global
87 function and data symbols to the minimal symbol table.
91 som_symtab_read (abfd
, objfile
, section_offsets
)
93 struct objfile
*objfile
;
94 struct section_offsets
*section_offsets
;
96 unsigned int number_of_symbols
;
100 struct symbol_dictionary_record
*buf
, *bufp
, *endbufp
;
102 CONST
int symsize
= sizeof (struct symbol_dictionary_record
);
103 CORE_ADDR text_offset
, data_offset
;
106 text_offset
= ANOFFSET (section_offsets
, 0);
107 data_offset
= ANOFFSET (section_offsets
, 1);
109 number_of_symbols
= bfd_get_symcount (abfd
);
111 buf
= alloca (symsize
* number_of_symbols
);
112 bfd_seek (abfd
, obj_som_sym_filepos (abfd
), SEEK_SET
);
113 val
= bfd_read (buf
, symsize
* number_of_symbols
, 1, abfd
);
114 if (val
!= symsize
* number_of_symbols
)
115 error ("Couldn't read symbol dictionary!");
117 stringtab
= alloca (obj_som_stringtab_size (abfd
));
118 bfd_seek (abfd
, obj_som_str_filepos (abfd
), SEEK_SET
);
119 val
= bfd_read (stringtab
, obj_som_stringtab_size (abfd
), 1, abfd
);
120 if (val
!= obj_som_stringtab_size (abfd
))
121 error ("Can't read in HP string table.");
123 /* We need to determine if objfile is a dynamic executable (so we
124 can do the right thing for ST_ENTRY vs ST_CODE symbols).
126 There's nothing in the header which easily allows us to do
127 this. The only reliable way I know of is to check for the
128 existance of a $SHLIB_INFO$ section with a non-zero size. */
129 /* The code below is not a reliable way to check whether an
130 * executable is dynamic, so I commented it out - RT
131 * shlib_info = bfd_get_section_by_name (objfile->obfd, "$SHLIB_INFO$");
133 * dynamic = (bfd_section_size (objfile->obfd, shlib_info) != 0);
137 /* I replaced the code with a simple check for text offset not being
138 * zero. Still not 100% reliable, but a more reliable way of asking
139 * "is this a dynamic executable?" than the above. RT
141 dynamic
= (text_offset
!= 0);
143 endbufp
= buf
+ number_of_symbols
;
144 for (bufp
= buf
; bufp
< endbufp
; ++bufp
)
146 enum minimal_symbol_type ms_type
;
150 switch (bufp
->symbol_scope
)
154 switch (bufp
->symbol_type
)
164 symname
= bufp
->name
.n_strx
+ stringtab
;
166 bufp
->symbol_value
+= text_offset
;
167 #ifdef SMASH_TEXT_ADDRESS
168 SMASH_TEXT_ADDRESS (bufp
->symbol_value
);
173 symname
= bufp
->name
.n_strx
+ stringtab
;
174 /* For a dynamic executable, ST_ENTRY symbols are
175 the stubs, while the ST_CODE symbol is the real
178 ms_type
= mst_solib_trampoline
;
181 bufp
->symbol_value
+= text_offset
;
182 #ifdef SMASH_TEXT_ADDRESS
183 SMASH_TEXT_ADDRESS (bufp
->symbol_value
);
188 symname
= bufp
->name
.n_strx
+ stringtab
;
189 ms_type
= mst_solib_trampoline
;
190 bufp
->symbol_value
+= text_offset
;
191 #ifdef SMASH_TEXT_ADDRESS
192 SMASH_TEXT_ADDRESS (bufp
->symbol_value
);
197 symname
= bufp
->name
.n_strx
+ stringtab
;
198 bufp
->symbol_value
+= data_offset
;
207 /* SS_GLOBAL and SS_LOCAL are two names for the same thing (!). */
211 switch (bufp
->symbol_type
)
218 symname
= bufp
->name
.n_strx
+ stringtab
;
219 ms_type
= mst_file_text
;
220 bufp
->symbol_value
+= text_offset
;
221 #ifdef SMASH_TEXT_ADDRESS
222 SMASH_TEXT_ADDRESS (bufp
->symbol_value
);
226 /* Utah GCC 2.5, FSF GCC 2.6 and later generate correct local
227 label prefixes for stabs, constant data, etc. So we need
228 only filter out L$ symbols which are left in due to
229 limitations in how GAS generates SOM relocations.
231 When linking in the HPUX C-library the HP linker has
232 the nasty habit of placing section symbols from the literal
233 subspaces in the middle of the program's text. Filter
234 those out as best we can. Check for first and last character
237 And finally, the newer HP compilers emit crud like $PIC_foo$N
238 in some circumstance (PIC code I guess). It's also claimed
239 that they emit D$ symbols too. What stupidity. */
240 if ((symname
[0] == 'L' && symname
[1] == '$')
241 || (symname
[0] == '$' && symname
[strlen(symname
) - 1] == '$')
242 || (symname
[0] == 'D' && symname
[1] == '$')
243 || (strncmp (symname
, "$PIC", 4) == 0))
250 symname
= bufp
->name
.n_strx
+ stringtab
;
251 ms_type
= mst_file_text
;
252 bufp
->symbol_value
+= text_offset
;
253 #ifdef SMASH_TEXT_ADDRESS
254 SMASH_TEXT_ADDRESS (bufp
->symbol_value
);
259 symname
= bufp
->name
.n_strx
+ stringtab
;
260 /* For a dynamic executable, ST_ENTRY symbols are
261 the stubs, while the ST_CODE symbol is the real
264 ms_type
= mst_solib_trampoline
;
266 ms_type
= mst_file_text
;
267 bufp
->symbol_value
+= text_offset
;
268 #ifdef SMASH_TEXT_ADDRESS
269 SMASH_TEXT_ADDRESS (bufp
->symbol_value
);
274 symname
= bufp
->name
.n_strx
+ stringtab
;
275 ms_type
= mst_solib_trampoline
;
276 bufp
->symbol_value
+= text_offset
;
277 #ifdef SMASH_TEXT_ADDRESS
278 SMASH_TEXT_ADDRESS (bufp
->symbol_value
);
284 symname
= bufp
->name
.n_strx
+ stringtab
;
285 bufp
->symbol_value
+= data_offset
;
286 ms_type
= mst_file_data
;
287 goto check_strange_names
;
294 /* This can happen for common symbols when -E is passed to the
295 final link. No idea _why_ that would make the linker force
296 common symbols to have an SS_UNSAT scope, but it does.
298 This also happens for weak symbols, but their type is
301 switch (bufp
->symbol_type
)
305 symname
= bufp
->name
.n_strx
+ stringtab
;
306 bufp
->symbol_value
+= data_offset
;
319 if (bufp
->name
.n_strx
> obj_som_stringtab_size (abfd
))
320 error ("Invalid symbol data; bad HP string table offset: %d",
323 prim_record_minimal_symbol (symname
, bufp
->symbol_value
, ms_type
,
328 /* Scan and build partial symbols for a symbol file.
329 We have been initialized by a call to som_symfile_init, which
330 currently does nothing.
332 SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
333 in each section. This is ignored, as it isn't needed for SOM.
335 MAINLINE is true if we are reading the main symbol
336 table (as opposed to a shared lib or dynamically loaded file).
338 This function only does the minimum work necessary for letting the
339 user "name" things symbolically; it does not read the entire symtab.
340 Instead, it reads the external and static symbols and puts them in partial
341 symbol tables. When more extensive information is requested of a
342 file, the corresponding partial symbol table is mutated into a full
343 fledged symbol table by going back and reading the symbols
346 We look for sections with specific names, to tell us what debug
347 format to look for: FIXME!!!
349 somstab_build_psymtabs() handles STABS symbols.
351 Note that SOM files have a "minimal" symbol table, which is vaguely
352 reminiscent of a COFF symbol table, but has only the minimal information
353 necessary for linking. We process this also, and use the information to
354 build gdb's minimal symbol table. This gives us some minimal debugging
355 capability even for files compiled without -g. */
358 som_symfile_read (objfile
, section_offsets
, mainline
)
359 struct objfile
*objfile
;
360 struct section_offsets
*section_offsets
;
363 bfd
*abfd
= objfile
->obfd
;
364 struct cleanup
*back_to
;
366 do_pxdb (symfile_bfd_open (objfile
->name
));
368 init_minimal_symbol_collection ();
369 back_to
= make_cleanup ((make_cleanup_func
) discard_minimal_symbols
, 0);
371 /* Read in the import list and the export list. Currently
372 the export list isn't used; the import list is used in
373 hp-symtab-read.c to handle static vars declared in other
375 init_import_symbols (objfile
);
376 #if 0 /* Export symbols not used today 1997-08-05 */
377 init_export_symbols (objfile
);
379 objfile
->export_list
= NULL
;
380 objfile
->export_list_size
= 0;
383 /* Process the normal SOM symbol table first.
384 This reads in the DNTT and string table, but doesn't
385 actually scan the DNTT. It does scan the linker symbol
386 table and thus build up a "minimal symbol table". */
388 som_symtab_read (abfd
, objfile
, section_offsets
);
390 /* Now read information from the stabs debug sections.
391 This is a no-op for SOM.
392 Perhaps it is intended for some kind of mixed STABS/SOM
394 stabsect_build_psymtabs (objfile
, section_offsets
, mainline
,
395 "$GDB_SYMBOLS$", "$GDB_STRINGS$", "$TEXT$");
397 /* Now read the native debug information.
398 This builds the psymtab. This used to be done via a scan of
399 the DNTT, but is now done via the PXDB-built quick-lookup tables
400 together with a scan of the GNTT. See hp-psymtab-read.c. */
401 hpread_build_psymtabs (objfile
, section_offsets
, mainline
);
403 /* Install any minimal symbols that have been collected as the current
404 minimal symbols for this objfile.
405 Further symbol-reading is done incrementally, file-by-file,
406 in a step known as "psymtab-to-symtab" expansion. hp-symtab-read.c
407 contains the code to do the actual DNTT scanning and symtab building. */
408 install_minimal_symbols (objfile
);
410 /* Force hppa-tdep.c to re-read the unwind descriptors. */
411 objfile
->obj_private
= NULL
;
412 do_cleanups (back_to
);
415 /* Initialize anything that needs initializing when a completely new symbol
416 file is specified (not just adding some symbols from another file, e.g. a
419 We reinitialize buildsym, since we may be reading stabs from a SOM file. */
422 som_new_init (ignore
)
423 struct objfile
*ignore
;
425 stabsread_new_init ();
426 buildsym_new_init ();
429 /* Perform any local cleanups required when we are done with a particular
430 objfile. I.E, we are in the process of discarding all symbol information
431 for an objfile, freeing up all memory held for it, and unlinking the
432 objfile struct from the global list of known objfiles. */
435 som_symfile_finish (objfile
)
436 struct objfile
*objfile
;
438 if (objfile
-> sym_stab_info
!= NULL
)
440 mfree (objfile
-> md
, objfile
-> sym_stab_info
);
442 hpread_symfile_finish (objfile
);
445 /* SOM specific initialization routine for reading symbols. */
448 som_symfile_init (objfile
)
449 struct objfile
*objfile
;
451 /* SOM objects may be reordered, so set OBJF_REORDERED. If we
452 find this causes a significant slowdown in gdb then we could
453 set it in the debug symbol readers only when necessary. */
454 objfile
->flags
|= OBJF_REORDERED
;
455 hpread_symfile_init (objfile
);
458 /* SOM specific parsing routine for section offsets.
460 Plain and simple for now. */
462 static struct section_offsets
*
463 som_symfile_offsets (objfile
, addr
)
464 struct objfile
*objfile
;
467 struct section_offsets
*section_offsets
;
470 objfile
->num_sections
= SECT_OFF_MAX
;
471 section_offsets
= (struct section_offsets
*)
472 obstack_alloc (&objfile
-> psymbol_obstack
, SIZEOF_SECTION_OFFSETS
);
474 /* First see if we're a shared library. If so, get the section
475 offsets from the library, else get them from addr. */
476 if (!som_solib_section_offsets (objfile
, section_offsets
))
478 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
479 ANOFFSET (section_offsets
, i
) = addr
;
482 return section_offsets
;
487 /* Check if a given symbol NAME is in the import list
489 1 => true, 0 => false
490 This is used in hp_symtab_read.c to deal with static variables
491 that are defined in a different shared library than the one
492 whose symbols are being processed. */
494 int is_in_import_list (name
, objfile
)
496 struct objfile
* objfile
;
505 for (i
=0; i
< objfile
->import_list_size
; i
++)
506 if (objfile
->import_list
[i
] && STREQ (name
, objfile
->import_list
[i
]))
512 /* Read in and initialize the SOM import list which is present
513 for all executables and shared libraries. The import list
514 consists of the symbols that are referenced in OBJFILE but
515 not defined there. (Variables that are imported are dealt
516 with as "loc_indirect" vars.)
517 Return value = number of import symbols read in. */
519 init_import_symbols (objfile
)
520 struct objfile
* objfile
;
522 unsigned int import_list
;
523 unsigned int import_list_size
;
524 unsigned int string_table
;
525 unsigned int string_table_size
;
526 char * string_buffer
;
530 asection
* text_section
; /* section handle */
531 unsigned int dl_header
[12]; /* SOM executable header */
533 /* A struct for an entry in the SOM import list */
535 int name
; /* index into the string table */
536 short dont_care1
; /* we don't use this */
537 unsigned char type
; /* 0 = NULL, 2 = Data, 3 = Code, 7 = Storage, 13 = Plabel */
538 unsigned int reserved2
: 8; /* not used */
541 /* We read 100 entries in at a time from the disk file. */
542 # define SOM_READ_IMPORTS_NUM 100
543 # define SOM_READ_IMPORTS_CHUNK_SIZE (sizeof (SomImportEntry) * SOM_READ_IMPORTS_NUM)
544 SomImportEntry buffer
[SOM_READ_IMPORTS_NUM
];
546 /* Initialize in case we error out */
547 objfile
->import_list
= NULL
;
548 objfile
->import_list_size
= 0;
550 #if 0 /* DEBUGGING */
551 printf ("Processing import list for %s\n", objfile
->name
);
554 /* It doesn't work, for some reason, to read in space $TEXT$;
555 the subspace $SHLIB_INFO$ has to be used. Some BFD quirk? pai/1997-08-05 */
556 text_section
= bfd_get_section_by_name (objfile
->obfd
, "$SHLIB_INFO$");
559 /* Get the SOM executable header */
560 bfd_get_section_contents (objfile
->obfd
, text_section
, dl_header
, 0, 12 * sizeof (int));
562 /* Check header version number for 10.x HP-UX */
563 /* Currently we deal only with 10.x systems; on 9.x the version # is 89060912.
564 FIXME: Change for future HP-UX releases and mods to the SOM executable format */
565 if (dl_header
[0] != 93092112)
568 import_list
= dl_header
[4];
569 import_list_size
= dl_header
[5];
570 if (!import_list_size
)
572 string_table
= dl_header
[10];
573 string_table_size
= dl_header
[11];
574 if (!string_table_size
)
577 /* Suck in SOM string table */
578 string_buffer
= (char *) xmalloc (string_table_size
);
579 bfd_get_section_contents (objfile
->obfd
, text_section
, string_buffer
,
580 string_table
, string_table_size
);
582 /* Allocate import list in the psymbol obstack; this has nothing
583 to do with psymbols, just a matter of convenience. We want the
584 import list to be freed when the objfile is deallocated */
586 = (ImportEntry
*) obstack_alloc (&objfile
->psymbol_obstack
,
587 import_list_size
* sizeof (ImportEntry
));
589 /* Read in the import entries, a bunch at a time */
591 j
< (import_list_size
/ SOM_READ_IMPORTS_NUM
);
594 bfd_get_section_contents (objfile
->obfd
, text_section
, buffer
,
595 import_list
+ j
* SOM_READ_IMPORTS_CHUNK_SIZE
,
596 SOM_READ_IMPORTS_CHUNK_SIZE
);
597 for (i
=0; i
< SOM_READ_IMPORTS_NUM
; i
++, k
++)
599 if (buffer
[i
].type
!= (unsigned char) 0)
601 objfile
->import_list
[k
]
602 = (char *) obstack_alloc (&objfile
->psymbol_obstack
, strlen (string_buffer
+ buffer
[i
].name
) + 1);
603 strcpy (objfile
->import_list
[k
], string_buffer
+ buffer
[i
].name
);
604 /* Some day we might want to record the type and other information too */
607 objfile
->import_list
[k
] = NULL
;
609 #if 0 /* DEBUGGING */
610 printf ("Import String %d:%d (%d), type %d is %s\n", j
, i
, k
,
611 (int) buffer
[i
].type
, objfile
->import_list
[k
]);
616 /* Get the leftovers */
617 if (k
< import_list_size
)
618 bfd_get_section_contents (objfile
->obfd
, text_section
, buffer
,
619 import_list
+ k
* sizeof (SomImportEntry
),
620 (import_list_size
- k
) * sizeof (SomImportEntry
));
621 for (i
=0; k
< import_list_size
; i
++, k
++)
623 if (buffer
[i
].type
!= (unsigned char) 0)
625 objfile
->import_list
[k
]
626 = (char *) obstack_alloc (&objfile
->psymbol_obstack
, strlen (string_buffer
+ buffer
[i
].name
) + 1);
627 strcpy (objfile
->import_list
[k
], string_buffer
+ buffer
[i
].name
);
628 /* Some day we might want to record the type and other information too */
631 objfile
->import_list
[k
] = NULL
;
632 #if 0 /* DEBUGGING */
633 printf ("Import String F:%d (%d), type %d, is %s\n", i
, k
,
634 (int) buffer
[i
].type
, objfile
->import_list
[k
]);
638 objfile
->import_list_size
= import_list_size
;
639 free (string_buffer
);
640 return import_list_size
;
643 /* Read in and initialize the SOM export list which is present
644 for all executables and shared libraries. The import list
645 consists of the symbols that are referenced in OBJFILE but
646 not defined there. (Variables that are imported are dealt
647 with as "loc_indirect" vars.)
648 Return value = number of import symbols read in. */
650 init_export_symbols (objfile
)
651 struct objfile
* objfile
;
653 unsigned int export_list
;
654 unsigned int export_list_size
;
655 unsigned int string_table
;
656 unsigned int string_table_size
;
657 char * string_buffer
;
661 asection
* text_section
; /* section handle */
662 unsigned int dl_header
[12]; /* SOM executable header */
664 /* A struct for an entry in the SOM export list */
666 int next
; /* for hash table use -- we don't use this */
667 int name
; /* index into string table */
668 int value
; /* offset or plabel */
669 int dont_care1
; /* not used */
670 unsigned char type
; /* 0 = NULL, 2 = Data, 3 = Code, 7 = Storage, 13 = Plabel */
671 char dont_care2
; /* not used */
672 short dont_care3
; /* not used */
675 /* We read 100 entries in at a time from the disk file. */
676 # define SOM_READ_EXPORTS_NUM 100
677 # define SOM_READ_EXPORTS_CHUNK_SIZE (sizeof (SomExportEntry) * SOM_READ_EXPORTS_NUM)
678 SomExportEntry buffer
[SOM_READ_EXPORTS_NUM
];
680 /* Initialize in case we error out */
681 objfile
->export_list
= NULL
;
682 objfile
->export_list_size
= 0;
684 #if 0 /* DEBUGGING */
685 printf ("Processing export list for %s\n", objfile
->name
);
688 /* It doesn't work, for some reason, to read in space $TEXT$;
689 the subspace $SHLIB_INFO$ has to be used. Some BFD quirk? pai/1997-08-05 */
690 text_section
= bfd_get_section_by_name (objfile
->obfd
, "$SHLIB_INFO$");
693 /* Get the SOM executable header */
694 bfd_get_section_contents (objfile
->obfd
, text_section
, dl_header
, 0, 12 * sizeof (int));
696 /* Check header version number for 10.x HP-UX */
697 /* Currently we deal only with 10.x systems; on 9.x the version # is 89060912.
698 FIXME: Change for future HP-UX releases and mods to the SOM executable format */
699 if (dl_header
[0] != 93092112)
702 export_list
= dl_header
[8];
703 export_list_size
= dl_header
[9];
704 if (!export_list_size
)
706 string_table
= dl_header
[10];
707 string_table_size
= dl_header
[11];
708 if (!string_table_size
)
711 /* Suck in SOM string table */
712 string_buffer
= (char *) xmalloc (string_table_size
);
713 bfd_get_section_contents (objfile
->obfd
, text_section
, string_buffer
,
714 string_table
, string_table_size
);
716 /* Allocate export list in the psymbol obstack; this has nothing
717 to do with psymbols, just a matter of convenience. We want the
718 export list to be freed when the objfile is deallocated */
720 = (ExportEntry
*) obstack_alloc (&objfile
->psymbol_obstack
,
721 export_list_size
* sizeof (ExportEntry
));
723 /* Read in the export entries, a bunch at a time */
725 j
< (export_list_size
/ SOM_READ_EXPORTS_NUM
);
728 bfd_get_section_contents (objfile
->obfd
, text_section
, buffer
,
729 export_list
+ j
* SOM_READ_EXPORTS_CHUNK_SIZE
,
730 SOM_READ_EXPORTS_CHUNK_SIZE
);
731 for (i
=0; i
< SOM_READ_EXPORTS_NUM
; i
++, k
++)
733 if (buffer
[i
].type
!= (unsigned char) 0)
735 objfile
->export_list
[k
].name
736 = (char *) obstack_alloc (&objfile
->psymbol_obstack
, strlen (string_buffer
+ buffer
[i
].name
) + 1);
737 strcpy (objfile
->export_list
[k
].name
, string_buffer
+ buffer
[i
].name
);
738 objfile
->export_list
[k
].address
= buffer
[i
].value
;
739 /* Some day we might want to record the type and other information too */
743 objfile
->export_list
[k
].name
= NULL
;
744 objfile
->export_list
[k
].address
= 0;
746 #if 0 /* DEBUGGING */
747 printf ("Export String %d:%d (%d), type %d is %s\n", j
, i
, k
,
748 (int) buffer
[i
].type
, objfile
->export_list
[k
].name
);
753 /* Get the leftovers */
754 if (k
< export_list_size
)
755 bfd_get_section_contents (objfile
->obfd
, text_section
, buffer
,
756 export_list
+ k
* sizeof (SomExportEntry
),
757 (export_list_size
- k
) * sizeof (SomExportEntry
));
758 for (i
=0; k
< export_list_size
; i
++, k
++)
760 if (buffer
[i
].type
!= (unsigned char) 0)
762 objfile
->export_list
[k
].name
763 = (char *) obstack_alloc (&objfile
->psymbol_obstack
, strlen (string_buffer
+ buffer
[i
].name
) + 1);
764 strcpy (objfile
->export_list
[k
].name
, string_buffer
+ buffer
[i
].name
);
765 /* Some day we might want to record the type and other information too */
766 objfile
->export_list
[k
].address
= buffer
[i
].value
;
770 objfile
->export_list
[k
].name
= NULL
;
771 objfile
->export_list
[k
].address
= 0;
773 #if 0 /* DEBUGGING */
774 printf ("Export String F:%d (%d), type %d, value %x is %s\n", i
, k
,
775 (int) buffer
[i
].type
, buffer
[i
].value
, objfile
->export_list
[k
].name
);
779 objfile
->export_list_size
= export_list_size
;
780 free (string_buffer
);
781 return export_list_size
;
786 /* Register that we are able to handle SOM object file formats. */
788 static struct sym_fns som_sym_fns
=
790 bfd_target_som_flavour
,
791 som_new_init
, /* sym_new_init: init anything gbl to entire symtab */
792 som_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
793 som_symfile_read
, /* sym_read: read a symbol file into symtab */
794 som_symfile_finish
, /* sym_finish: finished with file, cleanup */
795 som_symfile_offsets
, /* sym_offsets: Translate ext. to int. relocation */
796 NULL
/* next: pointer to next struct sym_fns */
800 _initialize_somread ()
802 add_symtab_fns (&som_sym_fns
);