]>
Commit | Line | Data |
---|---|---|
8fb8eb5c DE |
1 | /* Debug logging for the symbol file functions for the GNU debugger, GDB. |
2 | ||
213516ef | 3 | Copyright (C) 2013-2023 Free Software Foundation, Inc. |
8fb8eb5c DE |
4 | |
5 | Contributed by Cygnus Support, using pieces from other GDB modules. | |
6 | ||
7 | This file is part of GDB. | |
8 | ||
9 | This program is free software; you can redistribute it and/or modify | |
10 | it under the terms of the GNU General Public License as published by | |
11 | the Free Software Foundation; either version 3 of the License, or | |
12 | (at your option) any later version. | |
13 | ||
14 | This program is distributed in the hope that it will be useful, | |
15 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | GNU General Public License for more details. | |
18 | ||
19 | You should have received a copy of the GNU General Public License | |
20 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
21 | ||
22 | /* Note: Be careful with functions that can throw errors. | |
23 | We want to see a logging message regardless of whether an error was thrown. | |
24 | This typically means printing a message before calling the real function | |
25 | and then if the function returns a result printing a message after it | |
26 | returns. */ | |
27 | ||
28 | #include "defs.h" | |
29 | #include "gdbcmd.h" | |
30 | #include "objfiles.h" | |
76727919 | 31 | #include "observable.h" |
8fb8eb5c DE |
32 | #include "source.h" |
33 | #include "symtab.h" | |
34 | #include "symfile.h" | |
84d865e3 | 35 | #include "block.h" |
536a40f3 | 36 | #include "filenames.h" |
8fb8eb5c DE |
37 | |
38 | /* We need to save a pointer to the real symbol functions. | |
39 | Plus, the debug versions are malloc'd because we have to NULL out the | |
40 | ones that are NULL in the real copy. */ | |
41 | ||
42 | struct debug_sym_fns_data | |
43 | { | |
8c42777c TT |
44 | const struct sym_fns *real_sf = nullptr; |
45 | struct sym_fns debug_sf {}; | |
8fb8eb5c DE |
46 | }; |
47 | ||
48 | /* We need to record a pointer to the real set of functions for each | |
49 | objfile. */ | |
08b8a139 | 50 | static const registry<objfile>::key<debug_sym_fns_data> |
8c42777c | 51 | symfile_debug_objfile_data_key; |
8fb8eb5c | 52 | |
491144b5 CB |
53 | /* If true all calls to the symfile functions are logged. */ |
54 | static bool debug_symfile = false; | |
8fb8eb5c DE |
55 | |
56 | /* Return non-zero if symfile debug logging is installed. */ | |
57 | ||
58 | static int | |
59 | symfile_debug_installed (struct objfile *objfile) | |
60 | { | |
61 | return (objfile->sf != NULL | |
8c42777c | 62 | && symfile_debug_objfile_data_key.get (objfile) != NULL); |
8fb8eb5c DE |
63 | } |
64 | ||
8fb8eb5c DE |
65 | /* Utility return the name to print for SYMTAB. */ |
66 | ||
67 | static const char * | |
68 | debug_symtab_name (struct symtab *symtab) | |
69 | { | |
70 | return symtab_to_filename_for_display (symtab); | |
71 | } | |
72 | \f | |
8fb8eb5c | 73 | |
4d080b46 TT |
74 | /* See objfiles.h. */ |
75 | ||
76 | bool | |
77 | objfile::has_partial_symbols () | |
8fb8eb5c | 78 | { |
4d080b46 | 79 | bool retval = false; |
8fb8eb5c | 80 | |
4d080b46 TT |
81 | /* If we have not read psymbols, but we have a function capable of reading |
82 | them, then that is an indication that they are in fact available. Without | |
83 | this function the symbols may have been already read in but they also may | |
84 | not be present in this objfile. */ | |
e1114590 TT |
85 | for (const auto &iter : qf) |
86 | { | |
87 | if ((flags & OBJF_PSYMTABS_READ) == 0 | |
88 | && iter->can_lazily_read_symbols ()) | |
89 | retval = true; | |
90 | else | |
91 | retval = iter->has_symbols (this); | |
92 | if (retval) | |
93 | break; | |
94 | } | |
8fb8eb5c | 95 | |
4d080b46 | 96 | if (debug_symfile) |
6cb06a8c TT |
97 | gdb_printf (gdb_stdlog, "qf->has_symbols (%s) = %d\n", |
98 | objfile_debug_name (this), retval); | |
8fb8eb5c DE |
99 | |
100 | return retval; | |
101 | } | |
102 | ||
fc4d5ebf AB |
103 | /* See objfiles.h. */ |
104 | bool | |
105 | objfile::has_unexpanded_symtabs () | |
106 | { | |
107 | if (debug_symfile) | |
6cb06a8c TT |
108 | gdb_printf (gdb_stdlog, "qf->has_unexpanded_symtabs (%s)\n", |
109 | objfile_debug_name (this)); | |
fc4d5ebf AB |
110 | |
111 | bool result = false; | |
fcf8e814 | 112 | for (const auto &iter : qf_require_partial_symbols ()) |
fc4d5ebf AB |
113 | { |
114 | if (iter->has_unexpanded_symtabs (this)) | |
115 | { | |
116 | result = true; | |
117 | break; | |
118 | } | |
119 | } | |
120 | ||
121 | if (debug_symfile) | |
6cb06a8c TT |
122 | gdb_printf (gdb_stdlog, "qf->has_unexpanded_symtabs (%s) = %d\n", |
123 | objfile_debug_name (this), (result ? 1 : 0)); | |
fc4d5ebf AB |
124 | |
125 | return result; | |
126 | } | |
127 | ||
4d080b46 TT |
128 | struct symtab * |
129 | objfile::find_last_source_symtab () | |
8fb8eb5c | 130 | { |
4d080b46 | 131 | struct symtab *retval = nullptr; |
8fb8eb5c | 132 | |
4d080b46 | 133 | if (debug_symfile) |
6cb06a8c TT |
134 | gdb_printf (gdb_stdlog, "qf->find_last_source_symtab (%s)\n", |
135 | objfile_debug_name (this)); | |
8fb8eb5c | 136 | |
fcf8e814 | 137 | for (const auto &iter : qf_require_partial_symbols ()) |
e1114590 TT |
138 | { |
139 | retval = iter->find_last_source_symtab (this); | |
140 | if (retval != nullptr) | |
141 | break; | |
142 | } | |
8fb8eb5c | 143 | |
4d080b46 | 144 | if (debug_symfile) |
6cb06a8c TT |
145 | gdb_printf (gdb_stdlog, "qf->find_last_source_symtab (...) = %s\n", |
146 | retval ? debug_symtab_name (retval) : "NULL"); | |
8fb8eb5c DE |
147 | |
148 | return retval; | |
149 | } | |
150 | ||
4d080b46 TT |
151 | void |
152 | objfile::forget_cached_source_info () | |
8fb8eb5c | 153 | { |
4d080b46 | 154 | if (debug_symfile) |
6cb06a8c TT |
155 | gdb_printf (gdb_stdlog, "qf->forget_cached_source_info (%s)\n", |
156 | objfile_debug_name (this)); | |
8fb8eb5c | 157 | |
fcf8e814 | 158 | for (const auto &iter : qf_require_partial_symbols ()) |
e1114590 | 159 | iter->forget_cached_source_info (this); |
8fb8eb5c DE |
160 | } |
161 | ||
4d080b46 TT |
162 | bool |
163 | objfile::map_symtabs_matching_filename | |
164 | (const char *name, const char *real_path, | |
14bc53a8 | 165 | gdb::function_view<bool (symtab *)> callback) |
8fb8eb5c | 166 | { |
4d080b46 | 167 | if (debug_symfile) |
6cb06a8c TT |
168 | gdb_printf (gdb_stdlog, |
169 | "qf->map_symtabs_matching_filename (%s, \"%s\", " | |
170 | "\"%s\", %s)\n", | |
171 | objfile_debug_name (this), name, | |
172 | real_path ? real_path : NULL, | |
173 | host_address_to_string (&callback)); | |
8fb8eb5c | 174 | |
536a40f3 TT |
175 | bool retval = true; |
176 | const char *name_basename = lbasename (name); | |
177 | ||
178 | auto match_one_filename = [&] (const char *filename, bool basenames) | |
179 | { | |
180 | if (compare_filenames_for_search (filename, name)) | |
181 | return true; | |
182 | if (basenames && FILENAME_CMP (name_basename, filename) == 0) | |
183 | return true; | |
184 | if (real_path != nullptr && IS_ABSOLUTE_PATH (filename) | |
185 | && IS_ABSOLUTE_PATH (real_path)) | |
186 | return filename_cmp (filename, real_path) == 0; | |
187 | return false; | |
188 | }; | |
189 | ||
190 | compunit_symtab *last_made = this->compunit_symtabs; | |
191 | ||
192 | auto on_expansion = [&] (compunit_symtab *symtab) | |
193 | { | |
194 | /* The callback to iterate_over_some_symtabs returns false to keep | |
195 | going and true to continue, so we have to invert the result | |
196 | here, for expand_symtabs_matching. */ | |
197 | bool result = !iterate_over_some_symtabs (name, real_path, | |
198 | this->compunit_symtabs, | |
199 | last_made, | |
200 | callback); | |
201 | last_made = this->compunit_symtabs; | |
202 | return result; | |
203 | }; | |
204 | ||
fcf8e814 | 205 | for (const auto &iter : qf_require_partial_symbols ()) |
e1114590 | 206 | { |
536a40f3 TT |
207 | if (!iter->expand_symtabs_matching (this, |
208 | match_one_filename, | |
209 | nullptr, | |
210 | nullptr, | |
211 | on_expansion, | |
212 | (SEARCH_GLOBAL_BLOCK | |
213 | | SEARCH_STATIC_BLOCK), | |
214 | UNDEF_DOMAIN, | |
215 | ALL_DOMAIN)) | |
216 | { | |
217 | retval = false; | |
218 | break; | |
219 | } | |
e1114590 | 220 | } |
8fb8eb5c | 221 | |
4d080b46 | 222 | if (debug_symfile) |
6cb06a8c TT |
223 | gdb_printf (gdb_stdlog, |
224 | "qf->map_symtabs_matching_filename (...) = %d\n", | |
225 | retval); | |
8fb8eb5c | 226 | |
536a40f3 TT |
227 | /* We must re-invert the return value here to match the caller's |
228 | expectations. */ | |
229 | return !retval; | |
8fb8eb5c DE |
230 | } |
231 | ||
4d080b46 TT |
232 | struct compunit_symtab * |
233 | objfile::lookup_symbol (block_enum kind, const char *name, domain_enum domain) | |
8fb8eb5c | 234 | { |
4d080b46 | 235 | struct compunit_symtab *retval = nullptr; |
8fb8eb5c | 236 | |
4d080b46 | 237 | if (debug_symfile) |
6cb06a8c TT |
238 | gdb_printf (gdb_stdlog, |
239 | "qf->lookup_symbol (%s, %d, \"%s\", %s)\n", | |
240 | objfile_debug_name (this), kind, name, | |
241 | domain_name (domain)); | |
8fb8eb5c | 242 | |
84d865e3 TT |
243 | lookup_name_info lookup_name (name, symbol_name_match_type::FULL); |
244 | ||
245 | auto search_one_symtab = [&] (compunit_symtab *stab) | |
246 | { | |
247 | struct symbol *sym, *with_opaque = NULL; | |
af39c5c8 | 248 | const struct blockvector *bv = stab->blockvector (); |
63d609de | 249 | const struct block *block = bv->block (kind); |
84d865e3 TT |
250 | |
251 | sym = block_find_symbol (block, name, domain, | |
252 | block_find_non_opaque_type_preferred, | |
253 | &with_opaque); | |
254 | ||
255 | /* Some caution must be observed with overloaded functions | |
256 | and methods, since the index will not contain any overload | |
257 | information (but NAME might contain it). */ | |
258 | ||
259 | if (sym != NULL | |
81e32b6a | 260 | && symbol_matches_search_name (sym, lookup_name)) |
84d865e3 TT |
261 | { |
262 | retval = stab; | |
263 | /* Found it. */ | |
264 | return false; | |
265 | } | |
266 | if (with_opaque != NULL | |
81e32b6a | 267 | && symbol_matches_search_name (with_opaque, lookup_name)) |
84d865e3 TT |
268 | retval = stab; |
269 | ||
270 | /* Keep looking through other psymtabs. */ | |
271 | return true; | |
272 | }; | |
273 | ||
fcf8e814 | 274 | for (const auto &iter : qf_require_partial_symbols ()) |
e1114590 | 275 | { |
84d865e3 TT |
276 | if (!iter->expand_symtabs_matching (this, |
277 | nullptr, | |
278 | &lookup_name, | |
279 | nullptr, | |
280 | search_one_symtab, | |
281 | kind == GLOBAL_BLOCK | |
282 | ? SEARCH_GLOBAL_BLOCK | |
283 | : SEARCH_STATIC_BLOCK, | |
284 | domain, | |
285 | ALL_DOMAIN)) | |
e1114590 TT |
286 | break; |
287 | } | |
8fb8eb5c | 288 | |
4d080b46 | 289 | if (debug_symfile) |
6cb06a8c TT |
290 | gdb_printf (gdb_stdlog, "qf->lookup_symbol (...) = %s\n", |
291 | retval | |
292 | ? debug_symtab_name (retval->primary_filetab ()) | |
293 | : "NULL"); | |
8fb8eb5c DE |
294 | |
295 | return retval; | |
296 | } | |
297 | ||
4d080b46 | 298 | void |
4829711b | 299 | objfile::print_stats (bool print_bcache) |
8fb8eb5c | 300 | { |
4d080b46 | 301 | if (debug_symfile) |
6cb06a8c TT |
302 | gdb_printf (gdb_stdlog, "qf->print_stats (%s, %d)\n", |
303 | objfile_debug_name (this), print_bcache); | |
8fb8eb5c | 304 | |
fcf8e814 | 305 | for (const auto &iter : qf_require_partial_symbols ()) |
e1114590 | 306 | iter->print_stats (this, print_bcache); |
8fb8eb5c DE |
307 | } |
308 | ||
4d080b46 TT |
309 | void |
310 | objfile::dump () | |
8fb8eb5c | 311 | { |
4d080b46 | 312 | if (debug_symfile) |
6cb06a8c TT |
313 | gdb_printf (gdb_stdlog, "qf->dump (%s)\n", |
314 | objfile_debug_name (this)); | |
8fb8eb5c | 315 | |
e1114590 TT |
316 | for (const auto &iter : qf) |
317 | iter->dump (this); | |
8fb8eb5c DE |
318 | } |
319 | ||
4d080b46 TT |
320 | void |
321 | objfile::expand_symtabs_for_function (const char *func_name) | |
8fb8eb5c | 322 | { |
4d080b46 | 323 | if (debug_symfile) |
6cb06a8c TT |
324 | gdb_printf (gdb_stdlog, |
325 | "qf->expand_symtabs_for_function (%s, \"%s\")\n", | |
326 | objfile_debug_name (this), func_name); | |
8fb8eb5c | 327 | |
7089bd88 TT |
328 | lookup_name_info base_lookup (func_name, symbol_name_match_type::FULL); |
329 | lookup_name_info lookup_name = base_lookup.make_ignore_params (); | |
330 | ||
fcf8e814 | 331 | for (const auto &iter : qf_require_partial_symbols ()) |
7089bd88 TT |
332 | iter->expand_symtabs_matching (this, |
333 | nullptr, | |
334 | &lookup_name, | |
335 | nullptr, | |
336 | nullptr, | |
337 | (SEARCH_GLOBAL_BLOCK | |
338 | | SEARCH_STATIC_BLOCK), | |
339 | VAR_DOMAIN, | |
340 | ALL_DOMAIN); | |
8fb8eb5c DE |
341 | } |
342 | ||
4d080b46 TT |
343 | void |
344 | objfile::expand_all_symtabs () | |
8fb8eb5c | 345 | { |
4d080b46 | 346 | if (debug_symfile) |
6cb06a8c TT |
347 | gdb_printf (gdb_stdlog, "qf->expand_all_symtabs (%s)\n", |
348 | objfile_debug_name (this)); | |
8fb8eb5c | 349 | |
fcf8e814 | 350 | for (const auto &iter : qf_require_partial_symbols ()) |
e1114590 | 351 | iter->expand_all_symtabs (this); |
8fb8eb5c DE |
352 | } |
353 | ||
4d080b46 TT |
354 | void |
355 | objfile::expand_symtabs_with_fullname (const char *fullname) | |
8fb8eb5c | 356 | { |
4d080b46 | 357 | if (debug_symfile) |
6cb06a8c TT |
358 | gdb_printf (gdb_stdlog, |
359 | "qf->expand_symtabs_with_fullname (%s, \"%s\")\n", | |
360 | objfile_debug_name (this), fullname); | |
8fb8eb5c | 361 | |
90160b57 TT |
362 | const char *basename = lbasename (fullname); |
363 | auto file_matcher = [&] (const char *filename, bool basenames) | |
364 | { | |
365 | return filename_cmp (basenames ? basename : fullname, filename) == 0; | |
366 | }; | |
367 | ||
fcf8e814 | 368 | for (const auto &iter : qf_require_partial_symbols ()) |
90160b57 TT |
369 | iter->expand_symtabs_matching (this, |
370 | file_matcher, | |
371 | nullptr, | |
372 | nullptr, | |
373 | nullptr, | |
374 | (SEARCH_GLOBAL_BLOCK | |
375 | | SEARCH_STATIC_BLOCK), | |
376 | UNDEF_DOMAIN, | |
377 | ALL_DOMAIN); | |
8fb8eb5c DE |
378 | } |
379 | ||
4d080b46 | 380 | void |
0b7b2c2a | 381 | objfile::expand_matching_symbols |
4d080b46 | 382 | (const lookup_name_info &name, domain_enum domain, |
199b4314 | 383 | int global, |
199b4314 | 384 | symbol_compare_ftype *ordered_compare) |
8fb8eb5c | 385 | { |
4d080b46 | 386 | if (debug_symfile) |
6cb06a8c TT |
387 | gdb_printf (gdb_stdlog, |
388 | "qf->expand_matching_symbols (%s, %s, %d, %s)\n", | |
389 | objfile_debug_name (this), | |
390 | domain_name (domain), global, | |
391 | host_address_to_string (ordered_compare)); | |
8fb8eb5c | 392 | |
fcf8e814 | 393 | for (const auto &iter : qf_require_partial_symbols ()) |
0b7b2c2a TT |
394 | iter->expand_matching_symbols (this, name, domain, global, |
395 | ordered_compare); | |
8fb8eb5c DE |
396 | } |
397 | ||
df35e626 | 398 | bool |
4d080b46 TT |
399 | objfile::expand_symtabs_matching |
400 | (gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher, | |
c1a66c06 | 401 | const lookup_name_info *lookup_name, |
14bc53a8 PA |
402 | gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher, |
403 | gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify, | |
03a8ea51 | 404 | block_search_flags search_flags, |
3bfa51a7 | 405 | domain_enum domain, |
14bc53a8 | 406 | enum search_domain kind) |
8fb8eb5c | 407 | { |
4f348ca8 TT |
408 | /* This invariant is documented in quick-functions.h. */ |
409 | gdb_assert (lookup_name != nullptr || symbol_matcher == nullptr); | |
410 | ||
4d080b46 | 411 | if (debug_symfile) |
6cb06a8c TT |
412 | gdb_printf (gdb_stdlog, |
413 | "qf->expand_symtabs_matching (%s, %s, %s, %s, %s)\n", | |
414 | objfile_debug_name (this), | |
415 | host_address_to_string (&file_matcher), | |
416 | host_address_to_string (&symbol_matcher), | |
417 | host_address_to_string (&expansion_notify), | |
418 | search_domain_name (kind)); | |
4d080b46 | 419 | |
fcf8e814 | 420 | for (const auto &iter : qf_require_partial_symbols ()) |
df35e626 TT |
421 | if (!iter->expand_symtabs_matching (this, file_matcher, lookup_name, |
422 | symbol_matcher, expansion_notify, | |
3bfa51a7 | 423 | search_flags, domain, kind)) |
df35e626 TT |
424 | return false; |
425 | return true; | |
8fb8eb5c DE |
426 | } |
427 | ||
4d080b46 TT |
428 | struct compunit_symtab * |
429 | objfile::find_pc_sect_compunit_symtab (struct bound_minimal_symbol msymbol, | |
43f3e411 DE |
430 | CORE_ADDR pc, |
431 | struct obj_section *section, | |
432 | int warn_if_readin) | |
8fb8eb5c | 433 | { |
4d080b46 TT |
434 | struct compunit_symtab *retval = nullptr; |
435 | ||
436 | if (debug_symfile) | |
6cb06a8c TT |
437 | gdb_printf (gdb_stdlog, |
438 | "qf->find_pc_sect_compunit_symtab (%s, %s, %s, %s, %d)\n", | |
439 | objfile_debug_name (this), | |
440 | host_address_to_string (msymbol.minsym), | |
441 | hex_string (pc), | |
442 | host_address_to_string (section), | |
443 | warn_if_readin); | |
4d080b46 | 444 | |
fcf8e814 | 445 | for (const auto &iter : qf_require_partial_symbols ()) |
e1114590 TT |
446 | { |
447 | retval = iter->find_pc_sect_compunit_symtab (this, msymbol, pc, section, | |
448 | warn_if_readin); | |
449 | if (retval != nullptr) | |
450 | break; | |
451 | } | |
4d080b46 TT |
452 | |
453 | if (debug_symfile) | |
6cb06a8c TT |
454 | gdb_printf (gdb_stdlog, |
455 | "qf->find_pc_sect_compunit_symtab (...) = %s\n", | |
456 | retval | |
457 | ? debug_symtab_name (retval->primary_filetab ()) | |
458 | : "NULL"); | |
8fb8eb5c DE |
459 | |
460 | return retval; | |
461 | } | |
462 | ||
4d080b46 | 463 | void |
f4655dee TT |
464 | objfile::map_symbol_filenames (gdb::function_view<symbol_filename_ftype> fun, |
465 | bool need_fullname) | |
8fb8eb5c | 466 | { |
4d080b46 | 467 | if (debug_symfile) |
6cb06a8c TT |
468 | gdb_printf (gdb_stdlog, |
469 | "qf->map_symbol_filenames (%s, ..., %d)\n", | |
470 | objfile_debug_name (this), | |
471 | need_fullname); | |
8fb8eb5c | 472 | |
fcf8e814 | 473 | for (const auto &iter : qf_require_partial_symbols ()) |
f4655dee | 474 | iter->map_symbol_filenames (this, fun, need_fullname); |
8fb8eb5c DE |
475 | } |
476 | ||
4d080b46 TT |
477 | struct compunit_symtab * |
478 | objfile::find_compunit_symtab_by_address (CORE_ADDR address) | |
71a3c369 | 479 | { |
4d080b46 | 480 | if (debug_symfile) |
6cb06a8c TT |
481 | gdb_printf (gdb_stdlog, |
482 | "qf->find_compunit_symtab_by_address (%s, %s)\n", | |
483 | objfile_debug_name (this), | |
484 | hex_string (address)); | |
71a3c369 TT |
485 | |
486 | struct compunit_symtab *result = NULL; | |
fcf8e814 | 487 | for (const auto &iter : qf_require_partial_symbols ()) |
e1114590 TT |
488 | { |
489 | result = iter->find_compunit_symtab_by_address (this, address); | |
490 | if (result != nullptr) | |
491 | break; | |
492 | } | |
71a3c369 | 493 | |
4d080b46 | 494 | if (debug_symfile) |
6cb06a8c TT |
495 | gdb_printf (gdb_stdlog, |
496 | "qf->find_compunit_symtab_by_address (...) = %s\n", | |
497 | result | |
498 | ? debug_symtab_name (result->primary_filetab ()) | |
499 | : "NULL"); | |
4d080b46 TT |
500 | |
501 | return result; | |
502 | } | |
503 | ||
504 | enum language | |
505 | objfile::lookup_global_symbol_language (const char *name, | |
506 | domain_enum domain, | |
507 | bool *symbol_found_p) | |
508 | { | |
509 | enum language result = language_unknown; | |
e1114590 | 510 | *symbol_found_p = false; |
4d080b46 | 511 | |
fcf8e814 | 512 | for (const auto &iter : qf_require_partial_symbols ()) |
e1114590 TT |
513 | { |
514 | result = iter->lookup_global_symbol_language (this, name, domain, | |
515 | symbol_found_p); | |
516 | if (*symbol_found_p) | |
517 | break; | |
518 | } | |
71a3c369 TT |
519 | |
520 | return result; | |
521 | } | |
522 | ||
d1eef86d TT |
523 | void |
524 | objfile::require_partial_symbols (bool verbose) | |
525 | { | |
526 | if ((flags & OBJF_PSYMTABS_READ) == 0) | |
527 | { | |
528 | flags |= OBJF_PSYMTABS_READ; | |
529 | ||
e1114590 TT |
530 | bool printed = false; |
531 | for (const auto &iter : qf) | |
d1eef86d | 532 | { |
e1114590 TT |
533 | if (iter->can_lazily_read_symbols ()) |
534 | { | |
535 | if (verbose && !printed) | |
536 | { | |
6cb06a8c TT |
537 | gdb_printf (_("Reading symbols from %s...\n"), |
538 | objfile_name (this)); | |
e1114590 TT |
539 | printed = true; |
540 | } | |
541 | iter->read_partial_symbols (this); | |
542 | } | |
d1eef86d | 543 | } |
e1114590 | 544 | if (printed && !objfile_has_symbols (this)) |
6cb06a8c TT |
545 | gdb_printf (_("(No debugging symbols found in %s)\n"), |
546 | objfile_name (this)); | |
d1eef86d TT |
547 | } |
548 | } | |
549 | ||
8fb8eb5c DE |
550 | \f |
551 | /* Debugging version of struct sym_probe_fns. */ | |
552 | ||
814cf43a | 553 | static const std::vector<std::unique_ptr<probe>> & |
8fb8eb5c DE |
554 | debug_sym_get_probes (struct objfile *objfile) |
555 | { | |
19ba03f4 | 556 | const struct debug_sym_fns_data *debug_data |
8c42777c | 557 | = symfile_debug_objfile_data_key.get (objfile); |
8fb8eb5c | 558 | |
814cf43a | 559 | const std::vector<std::unique_ptr<probe>> &retval |
aaa63a31 | 560 | = debug_data->real_sf->sym_probe_fns->sym_get_probes (objfile); |
8fb8eb5c | 561 | |
6cb06a8c TT |
562 | gdb_printf (gdb_stdlog, |
563 | "probes->sym_get_probes (%s) = %s\n", | |
564 | objfile_debug_name (objfile), | |
565 | host_address_to_string (retval.data ())); | |
8fb8eb5c DE |
566 | |
567 | return retval; | |
568 | } | |
569 | ||
8fb8eb5c DE |
570 | static const struct sym_probe_fns debug_sym_probe_fns = |
571 | { | |
572 | debug_sym_get_probes, | |
8fb8eb5c DE |
573 | }; |
574 | \f | |
575 | /* Debugging version of struct sym_fns. */ | |
576 | ||
577 | static void | |
578 | debug_sym_new_init (struct objfile *objfile) | |
579 | { | |
19ba03f4 | 580 | const struct debug_sym_fns_data *debug_data |
8c42777c | 581 | = symfile_debug_objfile_data_key.get (objfile); |
8fb8eb5c | 582 | |
6cb06a8c TT |
583 | gdb_printf (gdb_stdlog, "sf->sym_new_init (%s)\n", |
584 | objfile_debug_name (objfile)); | |
8fb8eb5c DE |
585 | |
586 | debug_data->real_sf->sym_new_init (objfile); | |
587 | } | |
588 | ||
589 | static void | |
590 | debug_sym_init (struct objfile *objfile) | |
591 | { | |
19ba03f4 | 592 | const struct debug_sym_fns_data *debug_data |
8c42777c | 593 | = symfile_debug_objfile_data_key.get (objfile); |
8fb8eb5c | 594 | |
6cb06a8c TT |
595 | gdb_printf (gdb_stdlog, "sf->sym_init (%s)\n", |
596 | objfile_debug_name (objfile)); | |
8fb8eb5c DE |
597 | |
598 | debug_data->real_sf->sym_init (objfile); | |
599 | } | |
600 | ||
601 | static void | |
b15cc25c | 602 | debug_sym_read (struct objfile *objfile, symfile_add_flags symfile_flags) |
8fb8eb5c | 603 | { |
19ba03f4 | 604 | const struct debug_sym_fns_data *debug_data |
8c42777c | 605 | = symfile_debug_objfile_data_key.get (objfile); |
8fb8eb5c | 606 | |
6cb06a8c TT |
607 | gdb_printf (gdb_stdlog, "sf->sym_read (%s, 0x%x)\n", |
608 | objfile_debug_name (objfile), (unsigned) symfile_flags); | |
8fb8eb5c DE |
609 | |
610 | debug_data->real_sf->sym_read (objfile, symfile_flags); | |
611 | } | |
612 | ||
8fb8eb5c DE |
613 | static void |
614 | debug_sym_finish (struct objfile *objfile) | |
615 | { | |
19ba03f4 | 616 | const struct debug_sym_fns_data *debug_data |
8c42777c | 617 | = symfile_debug_objfile_data_key.get (objfile); |
8fb8eb5c | 618 | |
6cb06a8c TT |
619 | gdb_printf (gdb_stdlog, "sf->sym_finish (%s)\n", |
620 | objfile_debug_name (objfile)); | |
8fb8eb5c DE |
621 | |
622 | debug_data->real_sf->sym_finish (objfile); | |
623 | } | |
624 | ||
625 | static void | |
626 | debug_sym_offsets (struct objfile *objfile, | |
37e136b1 | 627 | const section_addr_info &info) |
8fb8eb5c | 628 | { |
19ba03f4 | 629 | const struct debug_sym_fns_data *debug_data |
8c42777c | 630 | = symfile_debug_objfile_data_key.get (objfile); |
8fb8eb5c | 631 | |
6cb06a8c TT |
632 | gdb_printf (gdb_stdlog, "sf->sym_offsets (%s, %s)\n", |
633 | objfile_debug_name (objfile), | |
634 | host_address_to_string (&info)); | |
8fb8eb5c DE |
635 | |
636 | debug_data->real_sf->sym_offsets (objfile, info); | |
637 | } | |
638 | ||
62982abd | 639 | static symfile_segment_data_up |
8fb8eb5c DE |
640 | debug_sym_segments (bfd *abfd) |
641 | { | |
642 | /* This API function is annoying, it doesn't take a "this" pointer. | |
643 | Fortunately it is only used in one place where we (re-)lookup the | |
644 | sym_fns table to use. Thus we will never be called. */ | |
645 | gdb_assert_not_reached ("debug_sym_segments called"); | |
646 | } | |
647 | ||
648 | static void | |
649 | debug_sym_read_linetable (struct objfile *objfile) | |
650 | { | |
19ba03f4 | 651 | const struct debug_sym_fns_data *debug_data |
8c42777c | 652 | = symfile_debug_objfile_data_key.get (objfile); |
8fb8eb5c | 653 | |
6cb06a8c TT |
654 | gdb_printf (gdb_stdlog, "sf->sym_read_linetable (%s)\n", |
655 | objfile_debug_name (objfile)); | |
8fb8eb5c DE |
656 | |
657 | debug_data->real_sf->sym_read_linetable (objfile); | |
658 | } | |
659 | ||
660 | static bfd_byte * | |
661 | debug_sym_relocate (struct objfile *objfile, asection *sectp, bfd_byte *buf) | |
662 | { | |
19ba03f4 | 663 | const struct debug_sym_fns_data *debug_data |
8c42777c | 664 | = symfile_debug_objfile_data_key.get (objfile); |
8fb8eb5c DE |
665 | bfd_byte *retval; |
666 | ||
667 | retval = debug_data->real_sf->sym_relocate (objfile, sectp, buf); | |
668 | ||
6cb06a8c TT |
669 | gdb_printf (gdb_stdlog, |
670 | "sf->sym_relocate (%s, %s, %s) = %s\n", | |
671 | objfile_debug_name (objfile), | |
672 | host_address_to_string (sectp), | |
673 | host_address_to_string (buf), | |
674 | host_address_to_string (retval)); | |
8fb8eb5c DE |
675 | |
676 | return retval; | |
677 | } | |
678 | ||
679 | /* Template of debugging version of struct sym_fns. | |
680 | A copy is made, with sym_flavour updated, and a pointer to the real table | |
681 | installed in real_sf, and then a pointer to the copy is installed in the | |
682 | objfile. */ | |
683 | ||
684 | static const struct sym_fns debug_sym_fns = | |
685 | { | |
686 | debug_sym_new_init, | |
687 | debug_sym_init, | |
688 | debug_sym_read, | |
8fb8eb5c DE |
689 | debug_sym_finish, |
690 | debug_sym_offsets, | |
691 | debug_sym_segments, | |
692 | debug_sym_read_linetable, | |
693 | debug_sym_relocate, | |
694 | &debug_sym_probe_fns, | |
8fb8eb5c DE |
695 | }; |
696 | \f | |
8fb8eb5c DE |
697 | /* Install the debugging versions of the symfile functions for OBJFILE. |
698 | Do not call this if the debug versions are already installed. */ | |
699 | ||
700 | static void | |
701 | install_symfile_debug_logging (struct objfile *objfile) | |
702 | { | |
703 | const struct sym_fns *real_sf; | |
704 | struct debug_sym_fns_data *debug_data; | |
705 | ||
706 | /* The debug versions should not already be installed. */ | |
707 | gdb_assert (!symfile_debug_installed (objfile)); | |
708 | ||
709 | real_sf = objfile->sf; | |
710 | ||
711 | /* Alas we have to preserve NULL entries in REAL_SF. */ | |
8c42777c | 712 | debug_data = new struct debug_sym_fns_data; |
8fb8eb5c DE |
713 | |
714 | #define COPY_SF_PTR(from, to, name, func) \ | |
715 | do { \ | |
716 | if ((from)->name) \ | |
717 | (to)->debug_sf.name = func; \ | |
718 | } while (0) | |
719 | ||
720 | COPY_SF_PTR (real_sf, debug_data, sym_new_init, debug_sym_new_init); | |
721 | COPY_SF_PTR (real_sf, debug_data, sym_init, debug_sym_init); | |
722 | COPY_SF_PTR (real_sf, debug_data, sym_read, debug_sym_read); | |
8fb8eb5c DE |
723 | COPY_SF_PTR (real_sf, debug_data, sym_finish, debug_sym_finish); |
724 | COPY_SF_PTR (real_sf, debug_data, sym_offsets, debug_sym_offsets); | |
725 | COPY_SF_PTR (real_sf, debug_data, sym_segments, debug_sym_segments); | |
726 | COPY_SF_PTR (real_sf, debug_data, sym_read_linetable, | |
727 | debug_sym_read_linetable); | |
728 | COPY_SF_PTR (real_sf, debug_data, sym_relocate, debug_sym_relocate); | |
729 | if (real_sf->sym_probe_fns) | |
730 | debug_data->debug_sf.sym_probe_fns = &debug_sym_probe_fns; | |
8fb8eb5c DE |
731 | |
732 | #undef COPY_SF_PTR | |
733 | ||
734 | debug_data->real_sf = real_sf; | |
8c42777c | 735 | symfile_debug_objfile_data_key.set (objfile, debug_data); |
8fb8eb5c DE |
736 | objfile->sf = &debug_data->debug_sf; |
737 | } | |
738 | ||
739 | /* Uninstall the debugging versions of the symfile functions for OBJFILE. | |
740 | Do not call this if the debug versions are not installed. */ | |
741 | ||
742 | static void | |
743 | uninstall_symfile_debug_logging (struct objfile *objfile) | |
744 | { | |
745 | struct debug_sym_fns_data *debug_data; | |
746 | ||
747 | /* The debug versions should be currently installed. */ | |
748 | gdb_assert (symfile_debug_installed (objfile)); | |
749 | ||
8c42777c | 750 | debug_data = symfile_debug_objfile_data_key.get (objfile); |
8fb8eb5c DE |
751 | |
752 | objfile->sf = debug_data->real_sf; | |
8c42777c | 753 | symfile_debug_objfile_data_key.clear (objfile); |
8fb8eb5c DE |
754 | } |
755 | ||
756 | /* Call this function to set OBJFILE->SF. | |
757 | Do not set OBJFILE->SF directly. */ | |
758 | ||
759 | void | |
760 | objfile_set_sym_fns (struct objfile *objfile, const struct sym_fns *sf) | |
761 | { | |
762 | if (symfile_debug_installed (objfile)) | |
763 | { | |
764 | gdb_assert (debug_symfile); | |
765 | /* Remove the current one, and reinstall a new one later. */ | |
766 | uninstall_symfile_debug_logging (objfile); | |
767 | } | |
768 | ||
769 | /* Assume debug logging is disabled. */ | |
770 | objfile->sf = sf; | |
771 | ||
772 | /* Turn debug logging on if enabled. */ | |
773 | if (debug_symfile) | |
774 | install_symfile_debug_logging (objfile); | |
775 | } | |
776 | ||
777 | static void | |
eb4c3f4a | 778 | set_debug_symfile (const char *args, int from_tty, struct cmd_list_element *c) |
8fb8eb5c | 779 | { |
94c93c35 | 780 | for (struct program_space *pspace : program_spaces) |
2030c079 | 781 | for (objfile *objfile : pspace->objfiles ()) |
99d89cde TT |
782 | { |
783 | if (debug_symfile) | |
784 | { | |
785 | if (!symfile_debug_installed (objfile)) | |
786 | install_symfile_debug_logging (objfile); | |
787 | } | |
788 | else | |
789 | { | |
790 | if (symfile_debug_installed (objfile)) | |
791 | uninstall_symfile_debug_logging (objfile); | |
792 | } | |
793 | } | |
8fb8eb5c DE |
794 | } |
795 | ||
796 | static void | |
797 | show_debug_symfile (struct ui_file *file, int from_tty, | |
798 | struct cmd_list_element *c, const char *value) | |
799 | { | |
6cb06a8c | 800 | gdb_printf (file, _("Symfile debugging is %s.\n"), value); |
8fb8eb5c DE |
801 | } |
802 | ||
6c265988 | 803 | void _initialize_symfile_debug (); |
8fb8eb5c | 804 | void |
6c265988 | 805 | _initialize_symfile_debug () |
8fb8eb5c | 806 | { |
8fb8eb5c DE |
807 | add_setshow_boolean_cmd ("symfile", no_class, &debug_symfile, _("\ |
808 | Set debugging of the symfile functions."), _("\ | |
809 | Show debugging of the symfile functions."), _("\ | |
810 | When enabled, all calls to the symfile functions are logged."), | |
811 | set_debug_symfile, show_debug_symfile, | |
812 | &setdebuglist, &showdebuglist); | |
813 | ||
814 | /* Note: We don't need a new-objfile observer because debug logging | |
815 | will be installed when objfile init'n calls objfile_set_sym_fns. */ | |
816 | } |