1 /* Read HP PA/Risc object files for GDB.
2 Copyright 1991, 1992, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
3 2004 Free Software Foundation, Inc.
4 Written by Fred Fish at Cygnus Support.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23 #include "defs.h"
24 #include "bfd.h"
25 #include <syms.h>
26 #include "symtab.h"
27 #include "symfile.h"
28 #include "objfiles.h"
29 #include "buildsym.h"
30 #include "stabsread.h"
31 #include "gdb-stabs.h"
32 #include "complaints.h"
33 #include "gdb_string.h"
34 #include "demangle.h"
35 #include "som.h"
36 #include "libhppa.h"
37
38 /* Various things we might complain about... */
39
40 static int init_import_symbols (struct objfile *objfile);
41
42 static void som_symfile_init (struct objfile *);
43
44 static void som_new_init (struct objfile *);
45
46 static void som_symfile_read (struct objfile *, int);
47
48 static void som_symfile_finish (struct objfile *);
49
50 static void som_symtab_read (bfd *, struct objfile *,
51 struct section_offsets *);
52
53 static void som_symfile_offsets (struct objfile *, struct section_addr_info *);
54
55 /* FIXME: These should really be in a common header somewhere */
56
57 extern void hpread_build_psymtabs (struct objfile *, int);
58
59 extern void hpread_symfile_finish (struct objfile *);
60
61 extern void hpread_symfile_init (struct objfile *);
62
63 extern void do_pxdb (bfd *);
64
65 /*
66
67 LOCAL FUNCTION
68
69 som_symtab_read -- read the symbol table of a SOM file
70
71 SYNOPSIS
72
73 void som_symtab_read (bfd *abfd, struct objfile *objfile,
74 struct section_offsets *section_offsets)
75
76 DESCRIPTION
77
78 Given an open bfd, a base address to relocate symbols to, and a
79 flag that specifies whether or not this bfd is for an executable
80 or not (may be shared library for example), add all the global
81 function and data symbols to the minimal symbol table.
82 */
83
84 static void
som_symtab_read(bfd * abfd,struct objfile * objfile,struct section_offsets * section_offsets)85 som_symtab_read (bfd *abfd, struct objfile *objfile,
86 struct section_offsets *section_offsets)
87 {
88 unsigned int number_of_symbols;
89 int val, dynamic;
90 char *stringtab;
91 asection *shlib_info;
92 struct symbol_dictionary_record *buf, *bufp, *endbufp;
93 char *symname;
94 CONST int symsize = sizeof (struct symbol_dictionary_record);
95 CORE_ADDR text_offset, data_offset;
96
97
98 text_offset = ANOFFSET (section_offsets, 0);
99 data_offset = ANOFFSET (section_offsets, 1);
100
101 number_of_symbols = bfd_get_symcount (abfd);
102
103 /* FIXME (alloca): could be quite large. */
104 buf = alloca (symsize * number_of_symbols);
105 bfd_seek (abfd, obj_som_sym_filepos (abfd), SEEK_SET);
106 val = bfd_bread (buf, symsize * number_of_symbols, abfd);
107 if (val != symsize * number_of_symbols)
108 error ("Couldn't read symbol dictionary!");
109
110 /* FIXME (alloca): could be quite large. */
111 stringtab = alloca (obj_som_stringtab_size (abfd));
112 bfd_seek (abfd, obj_som_str_filepos (abfd), SEEK_SET);
113 val = bfd_bread (stringtab, obj_som_stringtab_size (abfd), abfd);
114 if (val != obj_som_stringtab_size (abfd))
115 error ("Can't read in HP string table.");
116
117 /* We need to determine if objfile is a dynamic executable (so we
118 can do the right thing for ST_ENTRY vs ST_CODE symbols).
119
120 There's nothing in the header which easily allows us to do
121 this.
122
123 This code used to rely upon the existence of a $SHLIB_INFO$
124 section to make this determination. HP claims that it is
125 more accurate to check for a nonzero text offset, but they
126 have not provided any information about why that test is
127 more accurate. */
128 dynamic = (text_offset != 0);
129
130 endbufp = buf + number_of_symbols;
131 for (bufp = buf; bufp < endbufp; ++bufp)
132 {
133 enum minimal_symbol_type ms_type;
134
135 QUIT;
136
137 switch (bufp->symbol_scope)
138 {
139 case SS_UNIVERSAL:
140 case SS_EXTERNAL:
141 switch (bufp->symbol_type)
142 {
143 case ST_SYM_EXT:
144 case ST_ARG_EXT:
145 continue;
146
147 case ST_CODE:
148 case ST_PRI_PROG:
149 case ST_SEC_PROG:
150 case ST_MILLICODE:
151 symname = bufp->name.n_strx + stringtab;
152 ms_type = mst_text;
153 bufp->symbol_value += text_offset;
154 bufp->symbol_value = SMASH_TEXT_ADDRESS (bufp->symbol_value);
155 break;
156
157 case ST_ENTRY:
158 symname = bufp->name.n_strx + stringtab;
159 /* For a dynamic executable, ST_ENTRY symbols are
160 the stubs, while the ST_CODE symbol is the real
161 function. */
162 if (dynamic)
163 ms_type = mst_solib_trampoline;
164 else
165 ms_type = mst_text;
166 bufp->symbol_value += text_offset;
167 bufp->symbol_value = SMASH_TEXT_ADDRESS (bufp->symbol_value);
168 break;
169
170 case ST_STUB:
171 symname = bufp->name.n_strx + stringtab;
172 ms_type = mst_solib_trampoline;
173 bufp->symbol_value += text_offset;
174 bufp->symbol_value = SMASH_TEXT_ADDRESS (bufp->symbol_value);
175 break;
176
177 case ST_DATA:
178 symname = bufp->name.n_strx + stringtab;
179 bufp->symbol_value += data_offset;
180 ms_type = mst_data;
181 break;
182 default:
183 continue;
184 }
185 break;
186
187 #if 0
188 /* SS_GLOBAL and SS_LOCAL are two names for the same thing (!). */
189 case SS_GLOBAL:
190 #endif
191 case SS_LOCAL:
192 switch (bufp->symbol_type)
193 {
194 case ST_SYM_EXT:
195 case ST_ARG_EXT:
196 continue;
197
198 case ST_CODE:
199 symname = bufp->name.n_strx + stringtab;
200 ms_type = mst_file_text;
201 bufp->symbol_value += text_offset;
202 bufp->symbol_value = SMASH_TEXT_ADDRESS (bufp->symbol_value);
203
204 check_strange_names:
205 /* Utah GCC 2.5, FSF GCC 2.6 and later generate correct local
206 label prefixes for stabs, constant data, etc. So we need
207 only filter out L$ symbols which are left in due to
208 limitations in how GAS generates SOM relocations.
209
210 When linking in the HPUX C-library the HP linker has
211 the nasty habit of placing section symbols from the literal
212 subspaces in the middle of the program's text. Filter
213 those out as best we can. Check for first and last character
214 being '$'.
215
216 And finally, the newer HP compilers emit crud like $PIC_foo$N
217 in some circumstance (PIC code I guess). It's also claimed
218 that they emit D$ symbols too. What stupidity. */
219 if ((symname[0] == 'L' && symname[1] == '$')
220 || (symname[0] == '$' && symname[strlen (symname) - 1] == '$')
221 || (symname[0] == 'D' && symname[1] == '$')
222 || (strncmp (symname, "L0\001", 3) == 0)
223 || (strncmp (symname, "$PIC", 4) == 0))
224 continue;
225 break;
226
227 case ST_PRI_PROG:
228 case ST_SEC_PROG:
229 case ST_MILLICODE:
230 symname = bufp->name.n_strx + stringtab;
231 ms_type = mst_file_text;
232 bufp->symbol_value += text_offset;
233 bufp->symbol_value = SMASH_TEXT_ADDRESS (bufp->symbol_value);
234 break;
235
236 case ST_ENTRY:
237 symname = bufp->name.n_strx + stringtab;
238 /* SS_LOCAL symbols in a shared library do not have
239 export stubs, so we do not have to worry about
240 using mst_file_text vs mst_solib_trampoline here like
241 we do for SS_UNIVERSAL and SS_EXTERNAL symbols above. */
242 ms_type = mst_file_text;
243 bufp->symbol_value += text_offset;
244 bufp->symbol_value = SMASH_TEXT_ADDRESS (bufp->symbol_value);
245 break;
246
247 case ST_STUB:
248 symname = bufp->name.n_strx + stringtab;
249 ms_type = mst_solib_trampoline;
250 bufp->symbol_value += text_offset;
251 bufp->symbol_value = SMASH_TEXT_ADDRESS (bufp->symbol_value);
252 break;
253
254
255 case ST_DATA:
256 symname = bufp->name.n_strx + stringtab;
257 bufp->symbol_value += data_offset;
258 ms_type = mst_file_data;
259 goto check_strange_names;
260
261 default:
262 continue;
263 }
264 break;
265
266 /* This can happen for common symbols when -E is passed to the
267 final link. No idea _why_ that would make the linker force
268 common symbols to have an SS_UNSAT scope, but it does.
269
270 This also happens for weak symbols, but their type is
271 ST_DATA. */
272 case SS_UNSAT:
273 switch (bufp->symbol_type)
274 {
275 case ST_STORAGE:
276 case ST_DATA:
277 symname = bufp->name.n_strx + stringtab;
278 bufp->symbol_value += data_offset;
279 ms_type = mst_data;
280 break;
281
282 default:
283 continue;
284 }
285 break;
286
287 default:
288 continue;
289 }
290
291 if (bufp->name.n_strx > obj_som_stringtab_size (abfd))
292 error ("Invalid symbol data; bad HP string table offset: %d",
293 bufp->name.n_strx);
294
295 prim_record_minimal_symbol (symname, bufp->symbol_value, ms_type,
296 objfile);
297 }
298 }
299
300 /* Scan and build partial symbols for a symbol file.
301 We have been initialized by a call to som_symfile_init, which
302 currently does nothing.
303
304 SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
305 in each section. This is ignored, as it isn't needed for SOM.
306
307 MAINLINE is true if we are reading the main symbol
308 table (as opposed to a shared lib or dynamically loaded file).
309
310 This function only does the minimum work necessary for letting the
311 user "name" things symbolically; it does not read the entire symtab.
312 Instead, it reads the external and static symbols and puts them in partial
313 symbol tables. When more extensive information is requested of a
314 file, the corresponding partial symbol table is mutated into a full
315 fledged symbol table by going back and reading the symbols
316 for real.
317
318 We look for sections with specific names, to tell us what debug
319 format to look for: FIXME!!!
320
321 somstab_build_psymtabs() handles STABS symbols.
322
323 Note that SOM files have a "minimal" symbol table, which is vaguely
324 reminiscent of a COFF symbol table, but has only the minimal information
325 necessary for linking. We process this also, and use the information to
326 build gdb's minimal symbol table. This gives us some minimal debugging
327 capability even for files compiled without -g. */
328
329 static void
som_symfile_read(struct objfile * objfile,int mainline)330 som_symfile_read (struct objfile *objfile, int mainline)
331 {
332 bfd *abfd = objfile->obfd;
333 struct cleanup *back_to;
334
335 do_pxdb (symfile_bfd_open (objfile->name));
336
337 init_minimal_symbol_collection ();
338 back_to = make_cleanup_discard_minimal_symbols ();
339
340 /* Read in the import list and the export list. Currently
341 the export list isn't used; the import list is used in
342 hp-symtab-read.c to handle static vars declared in other
343 shared libraries. */
344 init_import_symbols (objfile);
345 #if 0 /* Export symbols not used today 1997-08-05 */
346 init_export_symbols (objfile);
347 #else
348 objfile->export_list = NULL;
349 objfile->export_list_size = 0;
350 #endif
351
352 /* Process the normal SOM symbol table first.
353 This reads in the DNTT and string table, but doesn't
354 actually scan the DNTT. It does scan the linker symbol
355 table and thus build up a "minimal symbol table". */
356
357 som_symtab_read (abfd, objfile, objfile->section_offsets);
358
359 /* Install any minimal symbols that have been collected as the current
360 minimal symbols for this objfile.
361 Further symbol-reading is done incrementally, file-by-file,
362 in a step known as "psymtab-to-symtab" expansion. hp-symtab-read.c
363 contains the code to do the actual DNTT scanning and symtab building. */
364 install_minimal_symbols (objfile);
365 do_cleanups (back_to);
366
367 /* Now read information from the stabs debug sections.
368 This is a no-op for SOM.
369 Perhaps it is intended for some kind of mixed STABS/SOM
370 situation? */
371 stabsect_build_psymtabs (objfile, mainline,
372 "$GDB_SYMBOLS$", "$GDB_STRINGS$", "$TEXT$");
373
374 /* Now read the native debug information.
375 This builds the psymtab. This used to be done via a scan of
376 the DNTT, but is now done via the PXDB-built quick-lookup tables
377 together with a scan of the GNTT. See hp-psymtab-read.c. */
378 hpread_build_psymtabs (objfile, mainline);
379
380 /* Force hppa-tdep.c to re-read the unwind descriptors. */
381 objfile->obj_private = NULL;
382 }
383
384 /* Initialize anything that needs initializing when a completely new symbol
385 file is specified (not just adding some symbols from another file, e.g. a
386 shared library).
387
388 We reinitialize buildsym, since we may be reading stabs from a SOM file. */
389
390 static void
som_new_init(struct objfile * ignore)391 som_new_init (struct objfile *ignore)
392 {
393 stabsread_new_init ();
394 buildsym_new_init ();
395 }
396
397 /* Perform any local cleanups required when we are done with a particular
398 objfile. I.E, we are in the process of discarding all symbol information
399 for an objfile, freeing up all memory held for it, and unlinking the
400 objfile struct from the global list of known objfiles. */
401
402 static void
som_symfile_finish(struct objfile * objfile)403 som_symfile_finish (struct objfile *objfile)
404 {
405 if (objfile->sym_stab_info != NULL)
406 {
407 xfree (objfile->sym_stab_info);
408 }
409 hpread_symfile_finish (objfile);
410 }
411
412 /* SOM specific initialization routine for reading symbols. */
413
414 static void
som_symfile_init(struct objfile * objfile)415 som_symfile_init (struct objfile *objfile)
416 {
417 /* SOM objects may be reordered, so set OBJF_REORDERED. If we
418 find this causes a significant slowdown in gdb then we could
419 set it in the debug symbol readers only when necessary. */
420 objfile->flags |= OBJF_REORDERED;
421 hpread_symfile_init (objfile);
422 }
423
424 /* SOM specific parsing routine for section offsets.
425
426 Plain and simple for now. */
427
428 static void
som_symfile_offsets(struct objfile * objfile,struct section_addr_info * addrs)429 som_symfile_offsets (struct objfile *objfile, struct section_addr_info *addrs)
430 {
431 int i;
432 CORE_ADDR text_addr;
433
434 objfile->num_sections = bfd_count_sections (objfile->obfd);
435 objfile->section_offsets = (struct section_offsets *)
436 obstack_alloc (&objfile->objfile_obstack,
437 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
438
439 /* FIXME: ezannoni 2000-04-20 The section names in SOM are not
440 .text, .data, etc, but $TEXT$, $DATA$,... We should initialize
441 SET_OFF_* from bfd. (See default_symfile_offsets()). But I don't
442 know the correspondence between SOM sections and GDB's idea of
443 section names. So for now we default to what is was before these
444 changes.*/
445 objfile->sect_index_text = 0;
446 objfile->sect_index_data = 1;
447 objfile->sect_index_bss = 2;
448 objfile->sect_index_rodata = 3;
449
450 /* First see if we're a shared library. If so, get the section
451 offsets from the library, else get them from addrs. */
452 if (!som_solib_section_offsets (objfile, objfile->section_offsets))
453 {
454 /* Note: Here is OK to compare with ".text" because this is the
455 name that gdb itself gives to that section, not the SOM
456 name. */
457 for (i = 0; i < objfile->num_sections && addrs->other[i].name; i++)
458 if (strcmp (addrs->other[i].name, ".text") == 0)
459 break;
460 text_addr = addrs->other[i].addr;
461
462 for (i = 0; i < objfile->num_sections; i++)
463 (objfile->section_offsets)->offsets[i] = text_addr;
464 }
465 }
466
467 /* Read in and initialize the SOM import list which is present
468 for all executables and shared libraries. The import list
469 consists of the symbols that are referenced in OBJFILE but
470 not defined there. (Variables that are imported are dealt
471 with as "loc_indirect" vars.)
472 Return value = number of import symbols read in. */
473 static int
init_import_symbols(struct objfile * objfile)474 init_import_symbols (struct objfile *objfile)
475 {
476 unsigned int import_list;
477 unsigned int import_list_size;
478 unsigned int string_table;
479 unsigned int string_table_size;
480 char *string_buffer;
481 int i;
482 int j;
483 int k;
484 asection *text_section; /* section handle */
485 unsigned int dl_header[12]; /* SOM executable header */
486
487 /* A struct for an entry in the SOM import list */
488 typedef struct
489 {
490 int name; /* index into the string table */
491 short dont_care1; /* we don't use this */
492 unsigned char type; /* 0 = NULL, 2 = Data, 3 = Code, 7 = Storage, 13 = Plabel */
493 unsigned int reserved2:8; /* not used */
494 }
495 SomImportEntry;
496
497 /* We read 100 entries in at a time from the disk file. */
498 #define SOM_READ_IMPORTS_NUM 100
499 #define SOM_READ_IMPORTS_CHUNK_SIZE (sizeof (SomImportEntry) * SOM_READ_IMPORTS_NUM)
500 SomImportEntry buffer[SOM_READ_IMPORTS_NUM];
501
502 /* Initialize in case we error out */
503 objfile->import_list = NULL;
504 objfile->import_list_size = 0;
505
506 /* It doesn't work, for some reason, to read in space $TEXT$;
507 the subspace $SHLIB_INFO$ has to be used. Some BFD quirk? pai/1997-08-05 */
508 text_section = bfd_get_section_by_name (objfile->obfd, "$SHLIB_INFO$");
509 if (!text_section)
510 return 0;
511 /* Get the SOM executable header */
512 bfd_get_section_contents (objfile->obfd, text_section, dl_header, 0, 12 * sizeof (int));
513
514 /* Check header version number for 10.x HP-UX */
515 /* Currently we deal only with 10.x systems; on 9.x the version # is 89060912.
516 FIXME: Change for future HP-UX releases and mods to the SOM executable format */
517 if (dl_header[0] != 93092112)
518 return 0;
519
520 import_list = dl_header[4];
521 import_list_size = dl_header[5];
522 if (!import_list_size)
523 return 0;
524 string_table = dl_header[10];
525 string_table_size = dl_header[11];
526 if (!string_table_size)
527 return 0;
528
529 /* Suck in SOM string table */
530 string_buffer = (char *) xmalloc (string_table_size);
531 bfd_get_section_contents (objfile->obfd, text_section, string_buffer,
532 string_table, string_table_size);
533
534 /* Allocate import list in the psymbol obstack; this has nothing
535 to do with psymbols, just a matter of convenience. We want the
536 import list to be freed when the objfile is deallocated */
537 objfile->import_list
538 = (ImportEntry *) obstack_alloc (&objfile->objfile_obstack,
539 import_list_size * sizeof (ImportEntry));
540
541 /* Read in the import entries, a bunch at a time */
542 for (j = 0, k = 0;
543 j < (import_list_size / SOM_READ_IMPORTS_NUM);
544 j++)
545 {
546 bfd_get_section_contents (objfile->obfd, text_section, buffer,
547 import_list + j * SOM_READ_IMPORTS_CHUNK_SIZE,
548 SOM_READ_IMPORTS_CHUNK_SIZE);
549 for (i = 0; i < SOM_READ_IMPORTS_NUM; i++, k++)
550 {
551 if (buffer[i].type != (unsigned char) 0)
552 {
553 objfile->import_list[k]
554 = (char *) obstack_alloc (&objfile->objfile_obstack, strlen (string_buffer + buffer[i].name) + 1);
555 strcpy (objfile->import_list[k], string_buffer + buffer[i].name);
556 /* Some day we might want to record the type and other information too */
557 }
558 else /* null type */
559 objfile->import_list[k] = NULL;
560
561 }
562 }
563
564 /* Get the leftovers */
565 if (k < import_list_size)
566 bfd_get_section_contents (objfile->obfd, text_section, buffer,
567 import_list + k * sizeof (SomImportEntry),
568 (import_list_size - k) * sizeof (SomImportEntry));
569 for (i = 0; k < import_list_size; i++, k++)
570 {
571 if (buffer[i].type != (unsigned char) 0)
572 {
573 objfile->import_list[k]
574 = (char *) obstack_alloc (&objfile->objfile_obstack, strlen (string_buffer + buffer[i].name) + 1);
575 strcpy (objfile->import_list[k], string_buffer + buffer[i].name);
576 /* Some day we might want to record the type and other information too */
577 }
578 else
579 objfile->import_list[k] = NULL;
580 }
581
582 objfile->import_list_size = import_list_size;
583 xfree (string_buffer);
584 return import_list_size;
585 }
586
587 /* Read in and initialize the SOM export list which is present
588 for all executables and shared libraries. The import list
589 consists of the symbols that are referenced in OBJFILE but
590 not defined there. (Variables that are imported are dealt
591 with as "loc_indirect" vars.)
592 Return value = number of import symbols read in. */
593 int
init_export_symbols(struct objfile * objfile)594 init_export_symbols (struct objfile *objfile)
595 {
596 unsigned int export_list;
597 unsigned int export_list_size;
598 unsigned int string_table;
599 unsigned int string_table_size;
600 char *string_buffer;
601 int i;
602 int j;
603 int k;
604 asection *text_section; /* section handle */
605 unsigned int dl_header[12]; /* SOM executable header */
606
607 /* A struct for an entry in the SOM export list */
608 typedef struct
609 {
610 int next; /* for hash table use -- we don't use this */
611 int name; /* index into string table */
612 int value; /* offset or plabel */
613 int dont_care1; /* not used */
614 unsigned char type; /* 0 = NULL, 2 = Data, 3 = Code, 7 = Storage, 13 = Plabel */
615 char dont_care2; /* not used */
616 short dont_care3; /* not used */
617 }
618 SomExportEntry;
619
620 /* We read 100 entries in at a time from the disk file. */
621 #define SOM_READ_EXPORTS_NUM 100
622 #define SOM_READ_EXPORTS_CHUNK_SIZE (sizeof (SomExportEntry) * SOM_READ_EXPORTS_NUM)
623 SomExportEntry buffer[SOM_READ_EXPORTS_NUM];
624
625 /* Initialize in case we error out */
626 objfile->export_list = NULL;
627 objfile->export_list_size = 0;
628
629 /* It doesn't work, for some reason, to read in space $TEXT$;
630 the subspace $SHLIB_INFO$ has to be used. Some BFD quirk? pai/1997-08-05 */
631 text_section = bfd_get_section_by_name (objfile->obfd, "$SHLIB_INFO$");
632 if (!text_section)
633 return 0;
634 /* Get the SOM executable header */
635 bfd_get_section_contents (objfile->obfd, text_section, dl_header, 0, 12 * sizeof (int));
636
637 /* Check header version number for 10.x HP-UX */
638 /* Currently we deal only with 10.x systems; on 9.x the version # is 89060912.
639 FIXME: Change for future HP-UX releases and mods to the SOM executable format */
640 if (dl_header[0] != 93092112)
641 return 0;
642
643 export_list = dl_header[8];
644 export_list_size = dl_header[9];
645 if (!export_list_size)
646 return 0;
647 string_table = dl_header[10];
648 string_table_size = dl_header[11];
649 if (!string_table_size)
650 return 0;
651
652 /* Suck in SOM string table */
653 string_buffer = (char *) xmalloc (string_table_size);
654 bfd_get_section_contents (objfile->obfd, text_section, string_buffer,
655 string_table, string_table_size);
656
657 /* Allocate export list in the psymbol obstack; this has nothing
658 to do with psymbols, just a matter of convenience. We want the
659 export list to be freed when the objfile is deallocated */
660 objfile->export_list
661 = (ExportEntry *) obstack_alloc (&objfile->objfile_obstack,
662 export_list_size * sizeof (ExportEntry));
663
664 /* Read in the export entries, a bunch at a time */
665 for (j = 0, k = 0;
666 j < (export_list_size / SOM_READ_EXPORTS_NUM);
667 j++)
668 {
669 bfd_get_section_contents (objfile->obfd, text_section, buffer,
670 export_list + j * SOM_READ_EXPORTS_CHUNK_SIZE,
671 SOM_READ_EXPORTS_CHUNK_SIZE);
672 for (i = 0; i < SOM_READ_EXPORTS_NUM; i++, k++)
673 {
674 if (buffer[i].type != (unsigned char) 0)
675 {
676 objfile->export_list[k].name
677 = (char *) obstack_alloc (&objfile->objfile_obstack, strlen (string_buffer + buffer[i].name) + 1);
678 strcpy (objfile->export_list[k].name, string_buffer + buffer[i].name);
679 objfile->export_list[k].address = buffer[i].value;
680 /* Some day we might want to record the type and other information too */
681 }
682 else
683 /* null type */
684 {
685 objfile->export_list[k].name = NULL;
686 objfile->export_list[k].address = 0;
687 }
688 }
689 }
690
691 /* Get the leftovers */
692 if (k < export_list_size)
693 bfd_get_section_contents (objfile->obfd, text_section, buffer,
694 export_list + k * sizeof (SomExportEntry),
695 (export_list_size - k) * sizeof (SomExportEntry));
696 for (i = 0; k < export_list_size; i++, k++)
697 {
698 if (buffer[i].type != (unsigned char) 0)
699 {
700 objfile->export_list[k].name
701 = (char *) obstack_alloc (&objfile->objfile_obstack, strlen (string_buffer + buffer[i].name) + 1);
702 strcpy (objfile->export_list[k].name, string_buffer + buffer[i].name);
703 /* Some day we might want to record the type and other information too */
704 objfile->export_list[k].address = buffer[i].value;
705 }
706 else
707 {
708 objfile->export_list[k].name = NULL;
709 objfile->export_list[k].address = 0;
710 }
711 }
712
713 objfile->export_list_size = export_list_size;
714 xfree (string_buffer);
715 return export_list_size;
716 }
717
718
719
720 /* Register that we are able to handle SOM object file formats. */
721
722 static struct sym_fns som_sym_fns =
723 {
724 bfd_target_som_flavour,
725 som_new_init, /* sym_new_init: init anything gbl to entire symtab */
726 som_symfile_init, /* sym_init: read initial info, setup for sym_read() */
727 som_symfile_read, /* sym_read: read a symbol file into symtab */
728 som_symfile_finish, /* sym_finish: finished with file, cleanup */
729 som_symfile_offsets, /* sym_offsets: Translate ext. to int. relocation */
730 NULL /* next: pointer to next struct sym_fns */
731 };
732
733 void
_initialize_somread(void)734 _initialize_somread (void)
735 {
736 add_symtab_fns (&som_sym_fns);
737 }
738