1 /* Read HP PA/Risc object files for GDB.
2 Copyright 1991, 1992, 1996, 1999 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 /* It doesn't work, for some reason, to read in space $TEXT$;
551 the subspace $SHLIB_INFO$ has to be used. Some BFD quirk? pai/1997-08-05 */
552 text_section = bfd_get_section_by_name (objfile->obfd, "$SHLIB_INFO$");
555 /* Get the SOM executable header */
556 bfd_get_section_contents (objfile->obfd, text_section, dl_header, 0, 12 * sizeof (int));
558 /* Check header version number for 10.x HP-UX */
559 /* Currently we deal only with 10.x systems; on 9.x the version # is 89060912.
560 FIXME: Change for future HP-UX releases and mods to the SOM executable format */
561 if (dl_header[0] != 93092112)
564 import_list = dl_header[4];
565 import_list_size = dl_header[5];
566 if (!import_list_size)
568 string_table = dl_header[10];
569 string_table_size = dl_header[11];
570 if (!string_table_size)
573 /* Suck in SOM string table */
574 string_buffer = (char *) xmalloc (string_table_size);
575 bfd_get_section_contents (objfile->obfd, text_section, string_buffer,
576 string_table, string_table_size);
578 /* Allocate import list in the psymbol obstack; this has nothing
579 to do with psymbols, just a matter of convenience. We want the
580 import list to be freed when the objfile is deallocated */
582 = (ImportEntry *) obstack_alloc (&objfile->psymbol_obstack,
583 import_list_size * sizeof (ImportEntry));
585 /* Read in the import entries, a bunch at a time */
587 j < (import_list_size / SOM_READ_IMPORTS_NUM);
590 bfd_get_section_contents (objfile->obfd, text_section, buffer,
591 import_list + j * SOM_READ_IMPORTS_CHUNK_SIZE,
592 SOM_READ_IMPORTS_CHUNK_SIZE);
593 for (i=0; i < SOM_READ_IMPORTS_NUM; i++, k++)
595 if (buffer[i].type != (unsigned char) 0)
597 objfile->import_list[k]
598 = (char *) obstack_alloc (&objfile->psymbol_obstack, strlen (string_buffer + buffer[i].name) + 1);
599 strcpy (objfile->import_list[k], string_buffer + buffer[i].name);
600 /* Some day we might want to record the type and other information too */
603 objfile->import_list[k] = NULL;
608 /* Get the leftovers */
609 if (k < import_list_size)
610 bfd_get_section_contents (objfile->obfd, text_section, buffer,
611 import_list + k * sizeof (SomImportEntry),
612 (import_list_size - k) * sizeof (SomImportEntry));
613 for (i=0; k < import_list_size; i++, k++)
615 if (buffer[i].type != (unsigned char) 0)
617 objfile->import_list[k]
618 = (char *) obstack_alloc (&objfile->psymbol_obstack, strlen (string_buffer + buffer[i].name) + 1);
619 strcpy (objfile->import_list[k], string_buffer + buffer[i].name);
620 /* Some day we might want to record the type and other information too */
623 objfile->import_list[k] = NULL;
626 objfile->import_list_size = import_list_size;
627 free (string_buffer);
628 return import_list_size;
631 /* Read in and initialize the SOM export list which is present
632 for all executables and shared libraries. The import list
633 consists of the symbols that are referenced in OBJFILE but
634 not defined there. (Variables that are imported are dealt
635 with as "loc_indirect" vars.)
636 Return value = number of import symbols read in. */
638 init_export_symbols (objfile)
639 struct objfile * objfile;
641 unsigned int export_list;
642 unsigned int export_list_size;
643 unsigned int string_table;
644 unsigned int string_table_size;
645 char * string_buffer;
649 asection * text_section; /* section handle */
650 unsigned int dl_header[12]; /* SOM executable header */
652 /* A struct for an entry in the SOM export list */
654 int next; /* for hash table use -- we don't use this */
655 int name; /* index into string table */
656 int value; /* offset or plabel */
657 int dont_care1; /* not used */
658 unsigned char type; /* 0 = NULL, 2 = Data, 3 = Code, 7 = Storage, 13 = Plabel */
659 char dont_care2; /* not used */
660 short dont_care3; /* not used */
663 /* We read 100 entries in at a time from the disk file. */
664 # define SOM_READ_EXPORTS_NUM 100
665 # define SOM_READ_EXPORTS_CHUNK_SIZE (sizeof (SomExportEntry) * SOM_READ_EXPORTS_NUM)
666 SomExportEntry buffer[SOM_READ_EXPORTS_NUM];
668 /* Initialize in case we error out */
669 objfile->export_list = NULL;
670 objfile->export_list_size = 0;
672 /* It doesn't work, for some reason, to read in space $TEXT$;
673 the subspace $SHLIB_INFO$ has to be used. Some BFD quirk? pai/1997-08-05 */
674 text_section = bfd_get_section_by_name (objfile->obfd, "$SHLIB_INFO$");
677 /* Get the SOM executable header */
678 bfd_get_section_contents (objfile->obfd, text_section, dl_header, 0, 12 * sizeof (int));
680 /* Check header version number for 10.x HP-UX */
681 /* Currently we deal only with 10.x systems; on 9.x the version # is 89060912.
682 FIXME: Change for future HP-UX releases and mods to the SOM executable format */
683 if (dl_header[0] != 93092112)
686 export_list = dl_header[8];
687 export_list_size = dl_header[9];
688 if (!export_list_size)
690 string_table = dl_header[10];
691 string_table_size = dl_header[11];
692 if (!string_table_size)
695 /* Suck in SOM string table */
696 string_buffer = (char *) xmalloc (string_table_size);
697 bfd_get_section_contents (objfile->obfd, text_section, string_buffer,
698 string_table, string_table_size);
700 /* Allocate export list in the psymbol obstack; this has nothing
701 to do with psymbols, just a matter of convenience. We want the
702 export list to be freed when the objfile is deallocated */
704 = (ExportEntry *) obstack_alloc (&objfile->psymbol_obstack,
705 export_list_size * sizeof (ExportEntry));
707 /* Read in the export entries, a bunch at a time */
709 j < (export_list_size / SOM_READ_EXPORTS_NUM);
712 bfd_get_section_contents (objfile->obfd, text_section, buffer,
713 export_list + j * SOM_READ_EXPORTS_CHUNK_SIZE,
714 SOM_READ_EXPORTS_CHUNK_SIZE);
715 for (i=0; i < SOM_READ_EXPORTS_NUM; i++, k++)
717 if (buffer[i].type != (unsigned char) 0)
719 objfile->export_list[k].name
720 = (char *) obstack_alloc (&objfile->psymbol_obstack, strlen (string_buffer + buffer[i].name) + 1);
721 strcpy (objfile->export_list[k].name, string_buffer + buffer[i].name);
722 objfile->export_list[k].address = buffer[i].value;
723 /* Some day we might want to record the type and other information too */
727 objfile->export_list[k].name = NULL;
728 objfile->export_list[k].address = 0;
733 /* Get the leftovers */
734 if (k < export_list_size)
735 bfd_get_section_contents (objfile->obfd, text_section, buffer,
736 export_list + k * sizeof (SomExportEntry),
737 (export_list_size - k) * sizeof (SomExportEntry));
738 for (i=0; k < export_list_size; i++, k++)
740 if (buffer[i].type != (unsigned char) 0)
742 objfile->export_list[k].name
743 = (char *) obstack_alloc (&objfile->psymbol_obstack, strlen (string_buffer + buffer[i].name) + 1);
744 strcpy (objfile->export_list[k].name, string_buffer + buffer[i].name);
745 /* Some day we might want to record the type and other information too */
746 objfile->export_list[k].address = buffer[i].value;
750 objfile->export_list[k].name = NULL;
751 objfile->export_list[k].address = 0;
755 objfile->export_list_size = export_list_size;
756 free (string_buffer);
757 return export_list_size;
762 /* Register that we are able to handle SOM object file formats. */
764 static struct sym_fns som_sym_fns =
766 bfd_target_som_flavour,
767 som_new_init, /* sym_new_init: init anything gbl to entire symtab */
768 som_symfile_init, /* sym_init: read initial info, setup for sym_read() */
769 som_symfile_read, /* sym_read: read a symbol file into symtab */
770 som_symfile_finish, /* sym_finish: finished with file, cleanup */
771 som_symfile_offsets, /* sym_offsets: Translate ext. to int. relocation */
772 NULL /* next: pointer to next struct sym_fns */
776 _initialize_somread ()
778 add_symtab_fns (&som_sym_fns);