Commit | Line | Data |
---|---|---|
db85f523 | 1 | /* Read NLM (NetWare Loadable Module) format executable files for GDB. |
ba47c66a | 2 | Copyright 1993, 1994 Free Software Foundation, Inc. |
db85f523 FF |
3 | Written by Fred Fish at Cygnus Support (fnf@cygnus.com). |
4 | ||
5 | This file is part of GDB. | |
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 2 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 | |
6c9638b4 | 19 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
db85f523 FF |
20 | |
21 | #include "defs.h" | |
2b576293 | 22 | #include "gdb_string.h" |
db85f523 FF |
23 | #include "bfd.h" |
24 | #include "symtab.h" | |
25 | #include "symfile.h" | |
26 | #include "objfiles.h" | |
27 | #include "gdb-stabs.h" | |
100f92e2 | 28 | #include "buildsym.h" |
6a6fe3db | 29 | #include "stabsread.h" |
db85f523 FF |
30 | |
31 | static void | |
32 | nlm_new_init PARAMS ((struct objfile *)); | |
33 | ||
34 | static void | |
35 | nlm_symfile_init PARAMS ((struct objfile *)); | |
36 | ||
37 | static void | |
38 | nlm_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int)); | |
39 | ||
40 | static void | |
41 | nlm_symfile_finish PARAMS ((struct objfile *)); | |
42 | ||
43 | static void | |
44 | nlm_symtab_read PARAMS ((bfd *, CORE_ADDR, struct objfile *)); | |
45 | ||
db85f523 FF |
46 | static void |
47 | record_minimal_symbol PARAMS ((char *, CORE_ADDR, enum minimal_symbol_type, | |
48 | struct objfile *)); | |
49 | ||
50 | ||
51 | /* Initialize anything that needs initializing when a completely new symbol | |
52 | file is specified (not just adding some symbols from another file, e.g. a | |
53 | shared library). | |
54 | ||
55 | We reinitialize buildsym, since gdb will be able to read stabs from an NLM | |
56 | file at some point in the near future. */ | |
57 | ||
58 | static void | |
59 | nlm_new_init (ignore) | |
60 | struct objfile *ignore; | |
61 | { | |
62 | stabsread_new_init (); | |
63 | buildsym_new_init (); | |
64 | } | |
65 | ||
66 | ||
67 | /* NLM specific initialization routine for reading symbols. | |
68 | ||
69 | It is passed a pointer to a struct sym_fns which contains, among other | |
70 | things, the BFD for the file whose symbols are being read, and a slot for | |
71 | a pointer to "private data" which we can fill with goodies. | |
72 | ||
73 | For now at least, we have nothing in particular to do, so this function is | |
74 | just a stub. */ | |
75 | ||
76 | static void | |
77 | nlm_symfile_init (ignore) | |
78 | struct objfile *ignore; | |
79 | { | |
80 | } | |
81 | ||
82 | static void | |
83 | record_minimal_symbol (name, address, ms_type, objfile) | |
84 | char *name; | |
85 | CORE_ADDR address; | |
86 | enum minimal_symbol_type ms_type; | |
87 | struct objfile *objfile; | |
88 | { | |
89 | name = obsavestring (name, strlen (name), &objfile -> symbol_obstack); | |
8d60affd | 90 | prim_record_minimal_symbol (name, address, ms_type, objfile); |
db85f523 FF |
91 | } |
92 | ||
93 | ||
94 | /* | |
95 | ||
96 | LOCAL FUNCTION | |
97 | ||
98 | nlm_symtab_read -- read the symbol table of an NLM file | |
99 | ||
100 | SYNOPSIS | |
101 | ||
102 | void nlm_symtab_read (bfd *abfd, CORE_ADDR addr, | |
103 | struct objfile *objfile) | |
104 | ||
105 | DESCRIPTION | |
106 | ||
107 | Given an open bfd, a base address to relocate symbols to, and a | |
108 | flag that specifies whether or not this bfd is for an executable | |
109 | or not (may be shared library for example), add all the global | |
110 | function and data symbols to the minimal symbol table. | |
111 | */ | |
112 | ||
113 | static void | |
114 | nlm_symtab_read (abfd, addr, objfile) | |
115 | bfd *abfd; | |
116 | CORE_ADDR addr; | |
117 | struct objfile *objfile; | |
118 | { | |
70f42bae | 119 | long storage_needed; |
db85f523 FF |
120 | asymbol *sym; |
121 | asymbol **symbol_table; | |
70f42bae ILT |
122 | long number_of_symbols; |
123 | long i; | |
db85f523 FF |
124 | struct cleanup *back_to; |
125 | CORE_ADDR symaddr; | |
126 | enum minimal_symbol_type ms_type; | |
127 | ||
70f42bae ILT |
128 | storage_needed = bfd_get_symtab_upper_bound (abfd); |
129 | if (storage_needed < 0) | |
130 | error ("Can't read symbols from %s: %s", bfd_get_filename (abfd), | |
131 | bfd_errmsg (bfd_get_error ())); | |
db85f523 FF |
132 | if (storage_needed > 0) |
133 | { | |
134 | symbol_table = (asymbol **) xmalloc (storage_needed); | |
135 | back_to = make_cleanup (free, symbol_table); | |
136 | number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); | |
70f42bae ILT |
137 | if (number_of_symbols < 0) |
138 | error ("Can't read symbols from %s: %s", bfd_get_filename (abfd), | |
139 | bfd_errmsg (bfd_get_error ())); | |
db85f523 FF |
140 | |
141 | for (i = 0; i < number_of_symbols; i++) | |
142 | { | |
143 | sym = symbol_table[i]; | |
a66e8382 | 144 | if (/*sym -> flags & BSF_GLOBAL*/ 1) |
db85f523 FF |
145 | { |
146 | /* Bfd symbols are section relative. */ | |
147 | symaddr = sym -> value + sym -> section -> vma; | |
148 | /* Relocate all non-absolute symbols by base address. */ | |
149 | if (sym -> section != &bfd_abs_section) | |
a4b4f520 | 150 | symaddr += addr; |
db85f523 FF |
151 | |
152 | /* For non-absolute symbols, use the type of the section | |
a4b4f520 | 153 | they are relative to, to intuit text/data. BFD provides |
db85f523 FF |
154 | no way of figuring this out for absolute symbols. */ |
155 | if (sym -> section -> flags & SEC_CODE) | |
a4b4f520 | 156 | ms_type = mst_text; |
db85f523 | 157 | else if (sym -> section -> flags & SEC_DATA) |
a4b4f520 | 158 | ms_type = mst_data; |
db85f523 | 159 | else |
a4b4f520 SG |
160 | ms_type = mst_unknown; |
161 | ||
db85f523 FF |
162 | record_minimal_symbol ((char *) sym -> name, symaddr, ms_type, |
163 | objfile); | |
164 | } | |
165 | } | |
166 | do_cleanups (back_to); | |
167 | } | |
168 | } | |
169 | ||
170 | ||
171 | /* Scan and build partial symbols for a symbol file. | |
172 | We have been initialized by a call to nlm_symfile_init, which | |
173 | currently does nothing. | |
174 | ||
175 | SECTION_OFFSETS is a set of offsets to apply to relocate the symbols | |
176 | in each section. We simplify it down to a single offset for all | |
177 | symbols. FIXME. | |
178 | ||
179 | MAINLINE is true if we are reading the main symbol | |
180 | table (as opposed to a shared lib or dynamically loaded file). | |
181 | ||
182 | This function only does the minimum work necessary for letting the | |
183 | user "name" things symbolically; it does not read the entire symtab. | |
184 | Instead, it reads the external and static symbols and puts them in partial | |
185 | symbol tables. When more extensive information is requested of a | |
186 | file, the corresponding partial symbol table is mutated into a full | |
187 | fledged symbol table by going back and reading the symbols | |
188 | for real. | |
189 | ||
190 | Note that NLM files have two sets of information that is potentially | |
191 | useful for building gdb's minimal symbol table. The first is a list | |
192 | of the publically exported symbols, and is currently used to build | |
193 | bfd's canonical symbol table. The second is an optional native debugging | |
194 | format which contains additional symbols (and possibly duplicates of | |
195 | the publically exported symbols). The optional native debugging format | |
196 | is not currently used. */ | |
197 | ||
198 | static void | |
199 | nlm_symfile_read (objfile, section_offsets, mainline) | |
200 | struct objfile *objfile; | |
201 | struct section_offsets *section_offsets; | |
202 | int mainline; | |
203 | { | |
204 | bfd *abfd = objfile -> obfd; | |
205 | struct cleanup *back_to; | |
206 | CORE_ADDR offset; | |
a4b4f520 | 207 | struct symbol *mainsym; |
db85f523 FF |
208 | |
209 | init_minimal_symbol_collection (); | |
210 | back_to = make_cleanup (discard_minimal_symbols, 0); | |
211 | ||
212 | /* FIXME, should take a section_offsets param, not just an offset. */ | |
213 | ||
214 | offset = ANOFFSET (section_offsets, 0); | |
215 | ||
216 | /* Process the NLM export records, which become the bfd's canonical symbol | |
217 | table. */ | |
218 | ||
219 | nlm_symtab_read (abfd, offset, objfile); | |
220 | ||
a66e8382 | 221 | stabsect_build_psymtabs (objfile, section_offsets, mainline, ".stab", |
6a86fa48 | 222 | ".stabstr", ".text"); |
a66e8382 | 223 | |
a4b4f520 SG |
224 | mainsym = lookup_symbol ("main", NULL, VAR_NAMESPACE, NULL, NULL); |
225 | ||
226 | if (mainsym | |
7314b3ee | 227 | && SYMBOL_CLASS(mainsym) == LOC_BLOCK) |
a4b4f520 SG |
228 | { |
229 | objfile->ei.main_func_lowpc = BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym)); | |
230 | objfile->ei.main_func_highpc = BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym)); | |
231 | } | |
232 | ||
db85f523 FF |
233 | /* FIXME: We could locate and read the optional native debugging format |
234 | here and add the symbols to the minimal symbol table. */ | |
235 | ||
db85f523 FF |
236 | /* Install any minimal symbols that have been collected as the current |
237 | minimal symbols for this objfile. */ | |
238 | ||
239 | install_minimal_symbols (objfile); | |
240 | ||
241 | do_cleanups (back_to); | |
242 | } | |
243 | ||
244 | ||
245 | /* Perform any local cleanups required when we are done with a particular | |
246 | objfile. I.E, we are in the process of discarding all symbol information | |
247 | for an objfile, freeing up all memory held for it, and unlinking the | |
248 | objfile struct from the global list of known objfiles. */ | |
249 | ||
250 | static void | |
251 | nlm_symfile_finish (objfile) | |
252 | struct objfile *objfile; | |
253 | { | |
254 | if (objfile -> sym_private != NULL) | |
255 | { | |
256 | mfree (objfile -> md, objfile -> sym_private); | |
257 | } | |
258 | } | |
259 | ||
4d57c599 | 260 | /* Register that we are able to handle NLM file format. */ |
db85f523 FF |
261 | |
262 | static struct sym_fns nlm_sym_fns = | |
263 | { | |
0eed42de | 264 | bfd_target_nlm_flavour, |
db85f523 FF |
265 | nlm_new_init, /* sym_new_init: init anything gbl to entire symtab */ |
266 | nlm_symfile_init, /* sym_init: read initial info, setup for sym_read() */ | |
267 | nlm_symfile_read, /* sym_read: read a symbol file into symtab */ | |
268 | nlm_symfile_finish, /* sym_finish: finished with file, cleanup */ | |
e74acce4 MA |
269 | default_symfile_offsets, |
270 | /* sym_offsets: Translate ext. to int. relocation */ | |
db85f523 FF |
271 | NULL /* next: pointer to next struct sym_fns */ |
272 | }; | |
273 | ||
274 | void | |
275 | _initialize_nlmread () | |
276 | { | |
277 | add_symtab_fns (&nlm_sym_fns); | |
278 | } |