Commit | Line | Data |
---|---|---|
ccefe4c4 TT |
1 | /* Private partial symbol table definitions. |
2 | ||
3666a048 | 3 | Copyright (C) 2009-2021 Free Software Foundation, Inc. |
ccefe4c4 TT |
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 3 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, see <http://www.gnu.org/licenses/>. */ | |
19 | ||
20 | #ifndef PSYMPRIV_H | |
21 | #define PSYMPRIV_H | |
22 | ||
23 | #include "psymtab.h" | |
906768f9 | 24 | #include "objfiles.h" |
31edb802 | 25 | #include "gdbsupport/gdb_string_view.h" |
ccefe4c4 TT |
26 | |
27 | /* A partial_symbol records the name, domain, and address class of | |
28 | symbols whose types we have not parsed yet. For functions, it also | |
29 | contains their memory address, so we can find them from a PC value. | |
30 | Each partial_symbol sits in a partial_symtab, all of which are chained | |
95cf5869 | 31 | on a partial symtab list and which points to the corresponding |
ccefe4c4 TT |
32 | normal symtab once the partial_symtab has been referenced. */ |
33 | ||
34 | /* This structure is space critical. See space comments at the top of | |
0df8b418 | 35 | symtab.h. */ |
ccefe4c4 | 36 | |
af97b416 | 37 | struct partial_symbol |
ccefe4c4 | 38 | { |
8a6d4234 TT |
39 | /* Return the section for this partial symbol, or nullptr if no |
40 | section has been set. */ | |
41 | struct obj_section *obj_section (struct objfile *objfile) const | |
42 | { | |
a52d653e | 43 | return ginfo.obj_section (objfile); |
8a6d4234 | 44 | } |
ccefe4c4 | 45 | |
02e9e7f7 TT |
46 | /* Return the unrelocated address of this partial symbol. */ |
47 | CORE_ADDR unrelocated_address () const | |
48 | { | |
af97b416 | 49 | return ginfo.value.address; |
02e9e7f7 TT |
50 | } |
51 | ||
52 | /* Return the address of this partial symbol, relocated according to | |
53 | the offsets provided in OBJFILE. */ | |
54 | CORE_ADDR address (const struct objfile *objfile) const | |
55 | { | |
a52d653e AB |
56 | return (ginfo.value.address |
57 | + objfile->section_offsets[ginfo.section_index ()]); | |
02e9e7f7 TT |
58 | } |
59 | ||
60 | /* Set the address of this partial symbol. The address must be | |
61 | unrelocated. */ | |
79748972 | 62 | void set_unrelocated_address (CORE_ADDR addr) |
02e9e7f7 | 63 | { |
af97b416 | 64 | ginfo.value.address = addr; |
02e9e7f7 TT |
65 | } |
66 | ||
af97b416 TT |
67 | /* Note that partial_symbol does not derive from general_symbol_info |
68 | due to the bcache. See add_psymbol_to_bcache. */ | |
69 | ||
70 | struct general_symbol_info ginfo; | |
71 | ||
ccefe4c4 TT |
72 | /* Name space code. */ |
73 | ||
51cdc993 | 74 | ENUM_BITFIELD(domain_enum_tag) domain : SYMBOL_DOMAIN_BITS; |
ccefe4c4 | 75 | |
f1e6e072 TT |
76 | /* Address class (for info_symbols). Note that we don't allow |
77 | synthetic "aclass" values here at present, simply because there's | |
78 | no need. */ | |
ccefe4c4 | 79 | |
51cdc993 | 80 | ENUM_BITFIELD(address_class) aclass : SYMBOL_ACLASS_BITS; |
ccefe4c4 TT |
81 | }; |
82 | ||
9439a077 TT |
83 | /* A convenience enum to give names to some constants used when |
84 | searching psymtabs. This is internal to psymtab and should not be | |
85 | used elsewhere. */ | |
86 | ||
87 | enum psymtab_search_status | |
88 | { | |
89 | PST_NOT_SEARCHED, | |
90 | PST_SEARCHED_AND_FOUND, | |
91 | PST_SEARCHED_AND_NOT_FOUND | |
92 | }; | |
93 | ||
932539d7 TT |
94 | /* Specify whether a partial psymbol should be allocated on the global |
95 | list or the static list. */ | |
96 | ||
97 | enum class psymbol_placement | |
98 | { | |
99 | STATIC, | |
100 | GLOBAL | |
101 | }; | |
102 | ||
ccefe4c4 TT |
103 | /* Each source file that has not been fully read in is represented by |
104 | a partial_symtab. This contains the information on where in the | |
105 | executable the debugging symbols for a specific file are, and a | |
106 | list of names of global symbols which are located in this file. | |
107 | They are all chained on partial symtab lists. | |
108 | ||
109 | Even after the source file has been read into a symtab, the | |
d4d947ae | 110 | partial_symtab remains around. */ |
ccefe4c4 TT |
111 | |
112 | struct partial_symtab | |
113 | { | |
32caafd0 TT |
114 | /* Allocate a new partial symbol table associated with OBJFILE. |
115 | FILENAME (which must be non-NULL) is the filename of this partial | |
116 | symbol table; it is copied into the appropriate storage. The | |
117 | partial symtab will also be installed using | |
118 | psymtab_storage::install. */ | |
119 | ||
120 | partial_symtab (const char *filename, struct objfile *objfile) | |
121 | ATTRIBUTE_NONNULL (2) ATTRIBUTE_NONNULL (3); | |
6f17252b | 122 | |
c3693a1d TT |
123 | /* Like the above, but also sets the initial text low and text high |
124 | from the ADDR argument, and sets the global- and | |
125 | static-offsets. */ | |
126 | ||
127 | partial_symtab (const char *filename, struct objfile *objfile, | |
128 | CORE_ADDR addr) | |
129 | ATTRIBUTE_NONNULL (2) ATTRIBUTE_NONNULL (3); | |
130 | ||
891813be TT |
131 | virtual ~partial_symtab () |
132 | { | |
133 | } | |
134 | ||
194d088f TV |
135 | /* Psymtab expansion is done in two steps: |
136 | - a call to read_symtab | |
137 | - while that call is in progress, calls to expand_psymtab can be made, | |
138 | both for this psymtab, and its dependencies. | |
139 | This makes a distinction between a toplevel psymtab (for which both | |
140 | read_symtab and expand_psymtab will be called) and a non-toplevel | |
141 | psymtab (for which only expand_psymtab will be called). The | |
142 | distinction can be used f.i. to do things before and after all | |
143 | dependencies of a top-level psymtab have been expanded. | |
144 | ||
145 | Read the full symbol table corresponding to this partial symbol | |
146 | table. Typically calls expand_psymtab. */ | |
891813be TT |
147 | virtual void read_symtab (struct objfile *) = 0; |
148 | ||
194d088f TV |
149 | /* Expand the full symbol table for this partial symbol table. Typically |
150 | calls expand_dependencies. */ | |
8566b89b TT |
151 | virtual void expand_psymtab (struct objfile *) = 0; |
152 | ||
194d088f TV |
153 | /* Ensure that all the dependencies are read in. Calls |
154 | expand_psymtab for each non-shared dependency. */ | |
48993951 | 155 | void expand_dependencies (struct objfile *); |
0494dbec | 156 | |
128a391f | 157 | /* Return true if the symtab corresponding to this psymtab has been |
5717c425 TT |
158 | read in in the context of this objfile. */ |
159 | virtual bool readin_p (struct objfile *) const = 0; | |
128a391f | 160 | |
5717c425 TT |
161 | /* Return a pointer to the compunit allocated for this source file |
162 | in the context of this objfile. | |
128a391f | 163 | |
5717c425 TT |
164 | Return nullptr if the compunit was not read in or if there was no |
165 | symtab. */ | |
166 | virtual struct compunit_symtab *get_compunit_symtab | |
167 | (struct objfile *) const = 0; | |
128a391f | 168 | |
79748972 TT |
169 | /* Return the raw low text address of this partial_symtab. */ |
170 | CORE_ADDR raw_text_low () const | |
4ae976d1 TT |
171 | { |
172 | return m_text_low; | |
173 | } | |
174 | ||
79748972 TT |
175 | /* Return the raw high text address of this partial_symtab. */ |
176 | CORE_ADDR raw_text_high () const | |
4ae976d1 TT |
177 | { |
178 | return m_text_high; | |
179 | } | |
180 | ||
79748972 TT |
181 | /* Return the relocated low text address of this partial_symtab. */ |
182 | CORE_ADDR text_low (struct objfile *objfile) const | |
183 | { | |
b3b3bada | 184 | return m_text_low + objfile->text_section_offset (); |
79748972 TT |
185 | } |
186 | ||
187 | /* Return the relocated high text address of this partial_symtab. */ | |
188 | CORE_ADDR text_high (struct objfile *objfile) const | |
189 | { | |
b3b3bada | 190 | return m_text_high + objfile->text_section_offset (); |
79748972 TT |
191 | } |
192 | ||
4ae976d1 TT |
193 | /* Set the low text address of this partial_symtab. */ |
194 | void set_text_low (CORE_ADDR addr) | |
195 | { | |
196 | m_text_low = addr; | |
52948f01 | 197 | text_low_valid = 1; |
4ae976d1 TT |
198 | } |
199 | ||
200 | /* Set the hight text address of this partial_symtab. */ | |
201 | void set_text_high (CORE_ADDR addr) | |
202 | { | |
203 | m_text_high = addr; | |
52948f01 | 204 | text_high_valid = 1; |
4ae976d1 TT |
205 | } |
206 | ||
932539d7 TT |
207 | /* Return true if this symtab is empty -- meaning that it contains |
208 | no symbols. It may still have dependencies. */ | |
209 | bool empty () const | |
210 | { | |
211 | return global_psymbols.empty () && static_psymbols.empty (); | |
212 | } | |
213 | ||
214 | /* Add a symbol to this partial symbol table of OBJFILE. | |
215 | ||
216 | If COPY_NAME is true, make a copy of NAME, otherwise use the passed | |
217 | reference. | |
218 | ||
219 | THECLASS is the type of symbol. | |
220 | ||
221 | SECTION is the index of the section of OBJFILE in which the symbol is found. | |
222 | ||
223 | WHERE determines whether the symbol goes in the list of static or global | |
224 | partial symbols. | |
225 | ||
226 | COREADDR is the address of the symbol. For partial symbols that don't have | |
227 | an address, zero is passed. | |
228 | ||
229 | LANGUAGE is the language from which the symbol originates. This will | |
230 | influence, amongst other things, how the symbol name is demangled. */ | |
231 | ||
232 | void add_psymbol (gdb::string_view name, | |
233 | bool copy_name, domain_enum domain, | |
234 | enum address_class theclass, | |
235 | short section, | |
236 | psymbol_placement where, | |
237 | CORE_ADDR coreaddr, | |
238 | enum language language, | |
239 | struct objfile *objfile); | |
240 | ||
241 | /* Add a symbol to this partial symbol table of OBJFILE. The psymbol | |
242 | must be fully constructed, and the names must be set and intern'd | |
243 | as appropriate. */ | |
244 | ||
245 | void add_psymbol (const partial_symbol &psym, | |
246 | psymbol_placement where, | |
247 | struct objfile *objfile); | |
248 | ||
4ae976d1 | 249 | |
ae7754b2 TT |
250 | /* Indicate that this partial symtab is complete. */ |
251 | ||
252 | void end (); | |
253 | ||
ccefe4c4 TT |
254 | /* Chain of all existing partial symtabs. */ |
255 | ||
6f17252b | 256 | struct partial_symtab *next = nullptr; |
ccefe4c4 | 257 | |
b4c41fc7 DE |
258 | /* Name of the source file which this partial_symtab defines, |
259 | or if the psymtab is anonymous then a descriptive name for | |
260 | debugging purposes, or "". It must not be NULL. */ | |
ccefe4c4 | 261 | |
6f17252b | 262 | const char *filename = nullptr; |
ccefe4c4 TT |
263 | |
264 | /* Full path of the source file. NULL if not known. */ | |
265 | ||
6f17252b | 266 | char *fullname = nullptr; |
ccefe4c4 TT |
267 | |
268 | /* Directory in which it was compiled, or NULL if we don't know. */ | |
269 | ||
6f17252b | 270 | const char *dirname = nullptr; |
ccefe4c4 | 271 | |
ccefe4c4 | 272 | /* Range of text addresses covered by this file; texthigh is the |
9750bca9 | 273 | beginning of the next section. Do not use if PSYMTABS_ADDRMAP_SUPPORTED |
4ae976d1 | 274 | is set. Do not refer directly to these fields. Instead, use the |
52948f01 TT |
275 | accessors. The validity of these fields is determined by the |
276 | text_low_valid and text_high_valid fields; these are located later | |
277 | in this structure for better packing. */ | |
ccefe4c4 | 278 | |
6f17252b TT |
279 | CORE_ADDR m_text_low = 0; |
280 | CORE_ADDR m_text_high = 0; | |
ccefe4c4 | 281 | |
9439a077 TT |
282 | /* If NULL, this is an ordinary partial symbol table. |
283 | ||
284 | If non-NULL, this holds a single includer of this partial symbol | |
285 | table, and this partial symbol table is a shared one. | |
286 | ||
287 | A shared psymtab is one that is referenced by multiple other | |
288 | psymtabs, and which conceptually has its contents directly | |
289 | included in those. | |
290 | ||
291 | Shared psymtabs have special semantics. When a search finds a | |
292 | symbol in a shared table, we instead return one of the non-shared | |
293 | tables that include this one. | |
294 | ||
295 | A shared psymtabs can be referred to by other shared ones. | |
296 | ||
297 | The psymtabs that refer to a shared psymtab will list the shared | |
298 | psymtab in their 'dependencies' array. | |
299 | ||
300 | In DWARF terms, a shared psymtab is a DW_TAG_partial_unit; but | |
301 | of course using a name based on that would be too confusing, so | |
302 | "shared" was chosen instead. | |
95cf5869 | 303 | |
9439a077 TT |
304 | Only a single user is needed because, when expanding a shared |
305 | psymtab, we only need to expand its "canonical" non-shared user. | |
306 | The choice of which one should be canonical is left to the | |
307 | debuginfo reader; it can be arbitrary. */ | |
308 | ||
6f17252b | 309 | struct partial_symtab *user = nullptr; |
9439a077 | 310 | |
e1b06ae2 TT |
311 | /* Array of pointers to all of the partial_symtab's which this one |
312 | depends on. Since this array can only be set to previous or | |
313 | the current (?) psymtab, this dependency tree is guaranteed not | |
314 | to have any loops. "depends on" means that symbols must be read | |
315 | for the dependencies before being read for this psymtab; this is | |
316 | for type references in stabs, where if foo.c includes foo.h, declarations | |
317 | in foo.h may use type numbers defined in foo.c. For other debugging | |
318 | formats there may be no need to use dependencies. */ | |
319 | ||
6f17252b | 320 | struct partial_symtab **dependencies = nullptr; |
e1b06ae2 | 321 | |
6f17252b | 322 | int number_of_dependencies = 0; |
e1b06ae2 | 323 | |
ccefe4c4 TT |
324 | /* Global symbol list. This list will be sorted after readin to |
325 | improve access. Binary search will be the usual method of | |
932539d7 | 326 | finding a symbol within it. */ |
ccefe4c4 | 327 | |
932539d7 | 328 | std::vector<partial_symbol *> global_psymbols; |
ccefe4c4 TT |
329 | |
330 | /* Static symbol list. This list will *not* be sorted after readin; | |
331 | to find a symbol in it, exhaustive search must be used. This is | |
332 | reasonable because searches through this list will eventually | |
333 | lead to either the read in of a files symbols for real (assumed | |
334 | to take a *lot* of time; check) or an error (and we don't care | |
932539d7 | 335 | how long errors take). */ |
ccefe4c4 | 336 | |
932539d7 | 337 | std::vector<partial_symbol *> static_psymbols; |
ccefe4c4 | 338 | |
9750bca9 JK |
339 | /* True iff objfile->psymtabs_addrmap is properly populated for this |
340 | partial_symtab. For discontiguous overlapping psymtabs is the only usable | |
341 | info in PSYMTABS_ADDRMAP. */ | |
342 | ||
6d94535f | 343 | bool psymtabs_addrmap_supported = false; |
9750bca9 | 344 | |
b4c41fc7 DE |
345 | /* True if the name of this partial symtab is not a source file name. */ |
346 | ||
6d94535f | 347 | bool anonymous = false; |
b4c41fc7 | 348 | |
9439a077 TT |
349 | /* A flag that is temporarily used when searching psymtabs. */ |
350 | ||
351 | ENUM_BITFIELD (psymtab_search_status) searched_flag : 2; | |
352 | ||
52948f01 TT |
353 | /* Validity of the m_text_low and m_text_high fields. */ |
354 | ||
355 | unsigned int text_low_valid : 1; | |
356 | unsigned int text_high_valid : 1; | |
128a391f TT |
357 | }; |
358 | ||
359 | /* A partial symtab that tracks the "readin" and "compunit_symtab" | |
360 | information in the ordinary way -- by storing it directly in this | |
361 | object. */ | |
362 | struct standard_psymtab : public partial_symtab | |
363 | { | |
364 | standard_psymtab (const char *filename, struct objfile *objfile) | |
365 | : partial_symtab (filename, objfile) | |
366 | { | |
367 | } | |
368 | ||
369 | standard_psymtab (const char *filename, struct objfile *objfile, | |
370 | CORE_ADDR addr) | |
371 | : partial_symtab (filename, objfile, addr) | |
372 | { | |
373 | } | |
374 | ||
5717c425 | 375 | bool readin_p (struct objfile *) const override |
128a391f TT |
376 | { |
377 | return readin; | |
378 | } | |
379 | ||
5717c425 | 380 | struct compunit_symtab *get_compunit_symtab (struct objfile *) const override |
128a391f TT |
381 | { |
382 | return compunit_symtab; | |
383 | } | |
384 | ||
385 | /* True if the symtab corresponding to this psymtab has been | |
386 | readin. */ | |
387 | ||
388 | bool readin = false; | |
52948f01 | 389 | |
43f3e411 | 390 | /* Pointer to compunit eventually allocated for this source file, 0 if |
ccefe4c4 TT |
391 | !readin or if we haven't looked for the symtab after it was readin. */ |
392 | ||
6f17252b | 393 | struct compunit_symtab *compunit_symtab = nullptr; |
891813be TT |
394 | }; |
395 | ||
396 | /* A partial_symtab that works in the historical db way. This should | |
397 | not be used in new code, but exists to transition the somewhat | |
398 | unmaintained "legacy" debug formats. */ | |
399 | ||
128a391f | 400 | struct legacy_psymtab : public standard_psymtab |
891813be TT |
401 | { |
402 | legacy_psymtab (const char *filename, struct objfile *objfile) | |
128a391f | 403 | : standard_psymtab (filename, objfile) |
891813be TT |
404 | { |
405 | } | |
406 | ||
407 | legacy_psymtab (const char *filename, struct objfile *objfile, | |
408 | CORE_ADDR addr) | |
128a391f | 409 | : standard_psymtab (filename, objfile, addr) |
891813be TT |
410 | { |
411 | } | |
412 | ||
413 | void read_symtab (struct objfile *objf) override | |
414 | { | |
415 | if (legacy_read_symtab) | |
416 | (*legacy_read_symtab) (this, objf); | |
417 | } | |
ccefe4c4 | 418 | |
8566b89b TT |
419 | void expand_psymtab (struct objfile *objf) override |
420 | { | |
421 | (*legacy_expand_psymtab) (this, objf); | |
422 | } | |
423 | ||
ccefe4c4 TT |
424 | /* Pointer to function which will read in the symtab corresponding to |
425 | this psymtab. */ | |
426 | ||
891813be | 427 | void (*legacy_read_symtab) (legacy_psymtab *, struct objfile *) = nullptr; |
ccefe4c4 | 428 | |
8566b89b TT |
429 | /* Pointer to function which will actually expand this psymtab into |
430 | a full symtab. */ | |
431 | ||
432 | void (*legacy_expand_psymtab) (legacy_psymtab *, struct objfile *) = nullptr; | |
433 | ||
ccefe4c4 TT |
434 | /* Information that lets read_symtab() locate the part of the symbol table |
435 | that this psymtab corresponds to. This information is private to the | |
436 | format-dependent symbol reading routines. For further detail examine | |
e38df1d0 | 437 | the various symbol reading modules. */ |
ccefe4c4 | 438 | |
6f17252b | 439 | void *read_symtab_private = nullptr; |
ccefe4c4 TT |
440 | }; |
441 | ||
906768f9 TT |
442 | /* Used when recording partial symbol tables. On destruction, |
443 | discards any partial symbol tables that have been built. However, | |
444 | the tables can be kept by calling the "keep" method. */ | |
445 | class psymtab_discarder | |
446 | { | |
447 | public: | |
448 | ||
484b1090 TT |
449 | psymtab_discarder (psymtab_storage *partial_symtabs) |
450 | : m_partial_symtabs (partial_symtabs), | |
451 | m_psymtab (partial_symtabs->psymtabs) | |
906768f9 TT |
452 | { |
453 | } | |
454 | ||
455 | ~psymtab_discarder () | |
456 | { | |
484b1090 TT |
457 | if (m_partial_symtabs != nullptr) |
458 | m_partial_symtabs->discard_psymtabs_to (m_psymtab); | |
906768f9 TT |
459 | } |
460 | ||
461 | /* Keep any partial symbol tables that were built. */ | |
462 | void keep () | |
463 | { | |
484b1090 | 464 | m_partial_symtabs = nullptr; |
906768f9 TT |
465 | } |
466 | ||
467 | private: | |
468 | ||
484b1090 TT |
469 | /* The partial symbol storage object. */ |
470 | psymtab_storage *m_partial_symtabs; | |
906768f9 TT |
471 | /* How far back to free. */ |
472 | struct partial_symtab *m_psymtab; | |
473 | }; | |
c9bf0622 | 474 | |
39298a5d TT |
475 | /* An implementation of quick_symbol_functions, specialized for |
476 | partial symbols. */ | |
477 | struct psymbol_functions : public quick_symbol_functions | |
478 | { | |
17d66340 TT |
479 | explicit psymbol_functions (const std::shared_ptr<psymtab_storage> &storage) |
480 | : m_partial_symtabs (storage) | |
481 | { | |
482 | } | |
483 | ||
39298a5d TT |
484 | bool has_symbols (struct objfile *objfile) override; |
485 | ||
486 | struct symtab *find_last_source_symtab (struct objfile *objfile) override; | |
487 | ||
488 | void forget_cached_source_info (struct objfile *objfile) override; | |
489 | ||
490 | bool map_symtabs_matching_filename | |
491 | (struct objfile *objfile, const char *name, const char *real_path, | |
492 | gdb::function_view<bool (symtab *)> callback) override; | |
493 | ||
494 | struct compunit_symtab *lookup_symbol (struct objfile *objfile, | |
495 | block_enum block_index, | |
496 | const char *name, | |
497 | domain_enum domain) override; | |
498 | ||
499 | enum language lookup_global_symbol_language (struct objfile *objfile, | |
500 | const char *name, | |
501 | domain_enum domain, | |
502 | bool *symbol_found_p) override; | |
503 | ||
4829711b | 504 | void print_stats (struct objfile *objfile, bool print_bcache) override; |
39298a5d TT |
505 | |
506 | void dump (struct objfile *objfile) override; | |
507 | ||
508 | void expand_symtabs_for_function (struct objfile *objfile, | |
509 | const char *func_name) override; | |
510 | ||
511 | void expand_all_symtabs (struct objfile *objfile) override; | |
512 | ||
513 | void expand_symtabs_with_fullname (struct objfile *objfile, | |
514 | const char *fullname) override; | |
515 | ||
516 | void map_matching_symbols | |
517 | (struct objfile *, | |
518 | const lookup_name_info &lookup_name, | |
519 | domain_enum domain, | |
520 | int global, | |
521 | gdb::function_view<symbol_found_callback_ftype> callback, | |
522 | symbol_compare_ftype *ordered_compare) override; | |
523 | ||
524 | void expand_symtabs_matching | |
525 | (struct objfile *objfile, | |
526 | gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher, | |
527 | const lookup_name_info *lookup_name, | |
528 | gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher, | |
529 | gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify, | |
530 | enum search_domain kind) override; | |
531 | ||
532 | struct compunit_symtab *find_pc_sect_compunit_symtab | |
533 | (struct objfile *objfile, struct bound_minimal_symbol msymbol, | |
534 | CORE_ADDR pc, struct obj_section *section, int warn_if_readin) override; | |
535 | ||
536 | struct compunit_symtab *find_compunit_symtab_by_address | |
537 | (struct objfile *objfile, CORE_ADDR address) override; | |
538 | ||
539 | void map_symbol_filenames (struct objfile *objfile, | |
540 | symbol_filename_ftype *fun, void *data, | |
541 | int need_fullname) override; | |
75336a5a TT |
542 | |
543 | void relocated () override | |
544 | { | |
545 | m_psymbol_map.clear (); | |
546 | } | |
547 | ||
17d66340 TT |
548 | /* Replace the partial symbol table storage in this object with |
549 | SYMS. */ | |
550 | void set_partial_symtabs (const std::shared_ptr<psymtab_storage> &syms) | |
551 | { | |
552 | m_partial_symtabs = syms; | |
553 | } | |
554 | ||
75336a5a TT |
555 | private: |
556 | ||
557 | void fill_psymbol_map (struct objfile *objfile, | |
558 | struct partial_symtab *psymtab, | |
559 | std::set<CORE_ADDR> *seen_addrs, | |
560 | const std::vector<partial_symbol *> &symbols); | |
561 | ||
17d66340 TT |
562 | /* Storage for the partial symbols. */ |
563 | std::shared_ptr<psymtab_storage> m_partial_symtabs; | |
564 | ||
75336a5a TT |
565 | /* Map symbol addresses to the partial symtab that defines the |
566 | object at that address. */ | |
567 | ||
568 | std::vector<std::pair<CORE_ADDR, partial_symtab *>> m_psymbol_map; | |
39298a5d TT |
569 | }; |
570 | ||
ccefe4c4 | 571 | #endif /* PSYMPRIV_H */ |