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 | { | |
0072c873 SM |
114 | /* Allocate a new partial symbol table. |
115 | ||
32caafd0 TT |
116 | FILENAME (which must be non-NULL) is the filename of this partial |
117 | symbol table; it is copied into the appropriate storage. The | |
118 | partial symtab will also be installed using | |
119 | psymtab_storage::install. */ | |
120 | ||
7b249e47 TT |
121 | partial_symtab (const char *filename, |
122 | psymtab_storage *partial_symtabs, | |
0072c873 | 123 | objfile_per_bfd_storage *objfile_per_bfd) |
32caafd0 | 124 | ATTRIBUTE_NONNULL (2) ATTRIBUTE_NONNULL (3); |
6f17252b | 125 | |
c3693a1d TT |
126 | /* Like the above, but also sets the initial text low and text high |
127 | from the ADDR argument, and sets the global- and | |
128 | static-offsets. */ | |
129 | ||
7b249e47 TT |
130 | partial_symtab (const char *filename, |
131 | psymtab_storage *partial_symtabs, | |
0072c873 | 132 | objfile_per_bfd_storage *objfile_per_bfd, |
c3693a1d TT |
133 | CORE_ADDR addr) |
134 | ATTRIBUTE_NONNULL (2) ATTRIBUTE_NONNULL (3); | |
135 | ||
891813be TT |
136 | virtual ~partial_symtab () |
137 | { | |
138 | } | |
139 | ||
194d088f TV |
140 | /* Psymtab expansion is done in two steps: |
141 | - a call to read_symtab | |
142 | - while that call is in progress, calls to expand_psymtab can be made, | |
143 | both for this psymtab, and its dependencies. | |
144 | This makes a distinction between a toplevel psymtab (for which both | |
145 | read_symtab and expand_psymtab will be called) and a non-toplevel | |
146 | psymtab (for which only expand_psymtab will be called). The | |
147 | distinction can be used f.i. to do things before and after all | |
148 | dependencies of a top-level psymtab have been expanded. | |
149 | ||
150 | Read the full symbol table corresponding to this partial symbol | |
151 | table. Typically calls expand_psymtab. */ | |
891813be TT |
152 | virtual void read_symtab (struct objfile *) = 0; |
153 | ||
194d088f TV |
154 | /* Expand the full symbol table for this partial symbol table. Typically |
155 | calls expand_dependencies. */ | |
8566b89b TT |
156 | virtual void expand_psymtab (struct objfile *) = 0; |
157 | ||
194d088f TV |
158 | /* Ensure that all the dependencies are read in. Calls |
159 | expand_psymtab for each non-shared dependency. */ | |
48993951 | 160 | void expand_dependencies (struct objfile *); |
0494dbec | 161 | |
128a391f | 162 | /* Return true if the symtab corresponding to this psymtab has been |
5717c425 TT |
163 | read in in the context of this objfile. */ |
164 | virtual bool readin_p (struct objfile *) const = 0; | |
128a391f | 165 | |
5717c425 TT |
166 | /* Return a pointer to the compunit allocated for this source file |
167 | in the context of this objfile. | |
128a391f | 168 | |
5717c425 TT |
169 | Return nullptr if the compunit was not read in or if there was no |
170 | symtab. */ | |
171 | virtual struct compunit_symtab *get_compunit_symtab | |
172 | (struct objfile *) const = 0; | |
128a391f | 173 | |
79748972 TT |
174 | /* Return the raw low text address of this partial_symtab. */ |
175 | CORE_ADDR raw_text_low () const | |
4ae976d1 TT |
176 | { |
177 | return m_text_low; | |
178 | } | |
179 | ||
79748972 TT |
180 | /* Return the raw high text address of this partial_symtab. */ |
181 | CORE_ADDR raw_text_high () const | |
4ae976d1 TT |
182 | { |
183 | return m_text_high; | |
184 | } | |
185 | ||
79748972 TT |
186 | /* Return the relocated low text address of this partial_symtab. */ |
187 | CORE_ADDR text_low (struct objfile *objfile) const | |
188 | { | |
b3b3bada | 189 | return m_text_low + objfile->text_section_offset (); |
79748972 TT |
190 | } |
191 | ||
192 | /* Return the relocated high text address of this partial_symtab. */ | |
193 | CORE_ADDR text_high (struct objfile *objfile) const | |
194 | { | |
b3b3bada | 195 | return m_text_high + objfile->text_section_offset (); |
79748972 TT |
196 | } |
197 | ||
4ae976d1 TT |
198 | /* Set the low text address of this partial_symtab. */ |
199 | void set_text_low (CORE_ADDR addr) | |
200 | { | |
201 | m_text_low = addr; | |
52948f01 | 202 | text_low_valid = 1; |
4ae976d1 TT |
203 | } |
204 | ||
205 | /* Set the hight text address of this partial_symtab. */ | |
206 | void set_text_high (CORE_ADDR addr) | |
207 | { | |
208 | m_text_high = addr; | |
52948f01 | 209 | text_high_valid = 1; |
4ae976d1 TT |
210 | } |
211 | ||
932539d7 TT |
212 | /* Return true if this symtab is empty -- meaning that it contains |
213 | no symbols. It may still have dependencies. */ | |
214 | bool empty () const | |
215 | { | |
216 | return global_psymbols.empty () && static_psymbols.empty (); | |
217 | } | |
218 | ||
219 | /* Add a symbol to this partial symbol table of OBJFILE. | |
220 | ||
221 | If COPY_NAME is true, make a copy of NAME, otherwise use the passed | |
222 | reference. | |
223 | ||
224 | THECLASS is the type of symbol. | |
225 | ||
226 | SECTION is the index of the section of OBJFILE in which the symbol is found. | |
227 | ||
228 | WHERE determines whether the symbol goes in the list of static or global | |
229 | partial symbols. | |
230 | ||
231 | COREADDR is the address of the symbol. For partial symbols that don't have | |
232 | an address, zero is passed. | |
233 | ||
234 | LANGUAGE is the language from which the symbol originates. This will | |
235 | influence, amongst other things, how the symbol name is demangled. */ | |
236 | ||
237 | void add_psymbol (gdb::string_view name, | |
238 | bool copy_name, domain_enum domain, | |
239 | enum address_class theclass, | |
240 | short section, | |
241 | psymbol_placement where, | |
242 | CORE_ADDR coreaddr, | |
243 | enum language language, | |
7b249e47 | 244 | psymtab_storage *partial_symtabs, |
932539d7 TT |
245 | struct objfile *objfile); |
246 | ||
247 | /* Add a symbol to this partial symbol table of OBJFILE. The psymbol | |
248 | must be fully constructed, and the names must be set and intern'd | |
249 | as appropriate. */ | |
250 | ||
251 | void add_psymbol (const partial_symbol &psym, | |
252 | psymbol_placement where, | |
7b249e47 | 253 | psymtab_storage *partial_symtabs, |
932539d7 TT |
254 | struct objfile *objfile); |
255 | ||
4ae976d1 | 256 | |
ae7754b2 TT |
257 | /* Indicate that this partial symtab is complete. */ |
258 | ||
259 | void end (); | |
260 | ||
ccefe4c4 TT |
261 | /* Chain of all existing partial symtabs. */ |
262 | ||
6f17252b | 263 | struct partial_symtab *next = nullptr; |
ccefe4c4 | 264 | |
b4c41fc7 DE |
265 | /* Name of the source file which this partial_symtab defines, |
266 | or if the psymtab is anonymous then a descriptive name for | |
267 | debugging purposes, or "". It must not be NULL. */ | |
ccefe4c4 | 268 | |
6f17252b | 269 | const char *filename = nullptr; |
ccefe4c4 TT |
270 | |
271 | /* Full path of the source file. NULL if not known. */ | |
272 | ||
6f17252b | 273 | char *fullname = nullptr; |
ccefe4c4 TT |
274 | |
275 | /* Directory in which it was compiled, or NULL if we don't know. */ | |
276 | ||
6f17252b | 277 | const char *dirname = nullptr; |
ccefe4c4 | 278 | |
ccefe4c4 | 279 | /* Range of text addresses covered by this file; texthigh is the |
9750bca9 | 280 | beginning of the next section. Do not use if PSYMTABS_ADDRMAP_SUPPORTED |
4ae976d1 | 281 | is set. Do not refer directly to these fields. Instead, use the |
52948f01 TT |
282 | accessors. The validity of these fields is determined by the |
283 | text_low_valid and text_high_valid fields; these are located later | |
284 | in this structure for better packing. */ | |
ccefe4c4 | 285 | |
6f17252b TT |
286 | CORE_ADDR m_text_low = 0; |
287 | CORE_ADDR m_text_high = 0; | |
ccefe4c4 | 288 | |
9439a077 TT |
289 | /* If NULL, this is an ordinary partial symbol table. |
290 | ||
291 | If non-NULL, this holds a single includer of this partial symbol | |
292 | table, and this partial symbol table is a shared one. | |
293 | ||
294 | A shared psymtab is one that is referenced by multiple other | |
295 | psymtabs, and which conceptually has its contents directly | |
296 | included in those. | |
297 | ||
298 | Shared psymtabs have special semantics. When a search finds a | |
299 | symbol in a shared table, we instead return one of the non-shared | |
300 | tables that include this one. | |
301 | ||
302 | A shared psymtabs can be referred to by other shared ones. | |
303 | ||
304 | The psymtabs that refer to a shared psymtab will list the shared | |
305 | psymtab in their 'dependencies' array. | |
306 | ||
307 | In DWARF terms, a shared psymtab is a DW_TAG_partial_unit; but | |
308 | of course using a name based on that would be too confusing, so | |
309 | "shared" was chosen instead. | |
95cf5869 | 310 | |
9439a077 TT |
311 | Only a single user is needed because, when expanding a shared |
312 | psymtab, we only need to expand its "canonical" non-shared user. | |
313 | The choice of which one should be canonical is left to the | |
314 | debuginfo reader; it can be arbitrary. */ | |
315 | ||
6f17252b | 316 | struct partial_symtab *user = nullptr; |
9439a077 | 317 | |
e1b06ae2 TT |
318 | /* Array of pointers to all of the partial_symtab's which this one |
319 | depends on. Since this array can only be set to previous or | |
320 | the current (?) psymtab, this dependency tree is guaranteed not | |
321 | to have any loops. "depends on" means that symbols must be read | |
322 | for the dependencies before being read for this psymtab; this is | |
323 | for type references in stabs, where if foo.c includes foo.h, declarations | |
324 | in foo.h may use type numbers defined in foo.c. For other debugging | |
325 | formats there may be no need to use dependencies. */ | |
326 | ||
6f17252b | 327 | struct partial_symtab **dependencies = nullptr; |
e1b06ae2 | 328 | |
6f17252b | 329 | int number_of_dependencies = 0; |
e1b06ae2 | 330 | |
ccefe4c4 TT |
331 | /* Global symbol list. This list will be sorted after readin to |
332 | improve access. Binary search will be the usual method of | |
932539d7 | 333 | finding a symbol within it. */ |
ccefe4c4 | 334 | |
932539d7 | 335 | std::vector<partial_symbol *> global_psymbols; |
ccefe4c4 TT |
336 | |
337 | /* Static symbol list. This list will *not* be sorted after readin; | |
338 | to find a symbol in it, exhaustive search must be used. This is | |
339 | reasonable because searches through this list will eventually | |
340 | lead to either the read in of a files symbols for real (assumed | |
341 | to take a *lot* of time; check) or an error (and we don't care | |
932539d7 | 342 | how long errors take). */ |
ccefe4c4 | 343 | |
932539d7 | 344 | std::vector<partial_symbol *> static_psymbols; |
ccefe4c4 | 345 | |
9750bca9 JK |
346 | /* True iff objfile->psymtabs_addrmap is properly populated for this |
347 | partial_symtab. For discontiguous overlapping psymtabs is the only usable | |
348 | info in PSYMTABS_ADDRMAP. */ | |
349 | ||
6d94535f | 350 | bool psymtabs_addrmap_supported = false; |
9750bca9 | 351 | |
b4c41fc7 DE |
352 | /* True if the name of this partial symtab is not a source file name. */ |
353 | ||
6d94535f | 354 | bool anonymous = false; |
b4c41fc7 | 355 | |
9439a077 TT |
356 | /* A flag that is temporarily used when searching psymtabs. */ |
357 | ||
358 | ENUM_BITFIELD (psymtab_search_status) searched_flag : 2; | |
359 | ||
52948f01 TT |
360 | /* Validity of the m_text_low and m_text_high fields. */ |
361 | ||
362 | unsigned int text_low_valid : 1; | |
363 | unsigned int text_high_valid : 1; | |
128a391f TT |
364 | }; |
365 | ||
366 | /* A partial symtab that tracks the "readin" and "compunit_symtab" | |
367 | information in the ordinary way -- by storing it directly in this | |
368 | object. */ | |
369 | struct standard_psymtab : public partial_symtab | |
370 | { | |
7b249e47 TT |
371 | standard_psymtab (const char *filename, |
372 | psymtab_storage *partial_symtabs, | |
0072c873 SM |
373 | objfile_per_bfd_storage *objfile_per_bfd) |
374 | : partial_symtab (filename, partial_symtabs, objfile_per_bfd) | |
128a391f TT |
375 | { |
376 | } | |
377 | ||
7b249e47 TT |
378 | standard_psymtab (const char *filename, |
379 | psymtab_storage *partial_symtabs, | |
0072c873 | 380 | objfile_per_bfd_storage *objfile_per_bfd, |
128a391f | 381 | CORE_ADDR addr) |
0072c873 | 382 | : partial_symtab (filename, partial_symtabs, objfile_per_bfd, addr) |
128a391f TT |
383 | { |
384 | } | |
385 | ||
5717c425 | 386 | bool readin_p (struct objfile *) const override |
128a391f TT |
387 | { |
388 | return readin; | |
389 | } | |
390 | ||
5717c425 | 391 | struct compunit_symtab *get_compunit_symtab (struct objfile *) const override |
128a391f TT |
392 | { |
393 | return compunit_symtab; | |
394 | } | |
395 | ||
396 | /* True if the symtab corresponding to this psymtab has been | |
397 | readin. */ | |
398 | ||
399 | bool readin = false; | |
52948f01 | 400 | |
43f3e411 | 401 | /* Pointer to compunit eventually allocated for this source file, 0 if |
ccefe4c4 TT |
402 | !readin or if we haven't looked for the symtab after it was readin. */ |
403 | ||
6f17252b | 404 | struct compunit_symtab *compunit_symtab = nullptr; |
891813be TT |
405 | }; |
406 | ||
407 | /* A partial_symtab that works in the historical db way. This should | |
408 | not be used in new code, but exists to transition the somewhat | |
409 | unmaintained "legacy" debug formats. */ | |
410 | ||
128a391f | 411 | struct legacy_psymtab : public standard_psymtab |
891813be | 412 | { |
7b249e47 TT |
413 | legacy_psymtab (const char *filename, |
414 | psymtab_storage *partial_symtabs, | |
0072c873 SM |
415 | objfile_per_bfd_storage *objfile_per_bfd) |
416 | : standard_psymtab (filename, partial_symtabs, objfile_per_bfd) | |
891813be TT |
417 | { |
418 | } | |
419 | ||
7b249e47 TT |
420 | legacy_psymtab (const char *filename, |
421 | psymtab_storage *partial_symtabs, | |
0072c873 | 422 | objfile_per_bfd_storage *objfile_per_bfd, |
891813be | 423 | CORE_ADDR addr) |
0072c873 | 424 | : standard_psymtab (filename, partial_symtabs, objfile_per_bfd, addr) |
891813be TT |
425 | { |
426 | } | |
427 | ||
428 | void read_symtab (struct objfile *objf) override | |
429 | { | |
430 | if (legacy_read_symtab) | |
431 | (*legacy_read_symtab) (this, objf); | |
432 | } | |
ccefe4c4 | 433 | |
8566b89b TT |
434 | void expand_psymtab (struct objfile *objf) override |
435 | { | |
436 | (*legacy_expand_psymtab) (this, objf); | |
437 | } | |
438 | ||
ccefe4c4 TT |
439 | /* Pointer to function which will read in the symtab corresponding to |
440 | this psymtab. */ | |
441 | ||
891813be | 442 | void (*legacy_read_symtab) (legacy_psymtab *, struct objfile *) = nullptr; |
ccefe4c4 | 443 | |
8566b89b TT |
444 | /* Pointer to function which will actually expand this psymtab into |
445 | a full symtab. */ | |
446 | ||
447 | void (*legacy_expand_psymtab) (legacy_psymtab *, struct objfile *) = nullptr; | |
448 | ||
ccefe4c4 TT |
449 | /* Information that lets read_symtab() locate the part of the symbol table |
450 | that this psymtab corresponds to. This information is private to the | |
451 | format-dependent symbol reading routines. For further detail examine | |
e38df1d0 | 452 | the various symbol reading modules. */ |
ccefe4c4 | 453 | |
6f17252b | 454 | void *read_symtab_private = nullptr; |
ccefe4c4 TT |
455 | }; |
456 | ||
906768f9 TT |
457 | /* Used when recording partial symbol tables. On destruction, |
458 | discards any partial symbol tables that have been built. However, | |
459 | the tables can be kept by calling the "keep" method. */ | |
460 | class psymtab_discarder | |
461 | { | |
462 | public: | |
463 | ||
484b1090 TT |
464 | psymtab_discarder (psymtab_storage *partial_symtabs) |
465 | : m_partial_symtabs (partial_symtabs), | |
466 | m_psymtab (partial_symtabs->psymtabs) | |
906768f9 TT |
467 | { |
468 | } | |
469 | ||
470 | ~psymtab_discarder () | |
471 | { | |
484b1090 TT |
472 | if (m_partial_symtabs != nullptr) |
473 | m_partial_symtabs->discard_psymtabs_to (m_psymtab); | |
906768f9 TT |
474 | } |
475 | ||
476 | /* Keep any partial symbol tables that were built. */ | |
477 | void keep () | |
478 | { | |
484b1090 | 479 | m_partial_symtabs = nullptr; |
906768f9 TT |
480 | } |
481 | ||
482 | private: | |
483 | ||
484b1090 TT |
484 | /* The partial symbol storage object. */ |
485 | psymtab_storage *m_partial_symtabs; | |
906768f9 TT |
486 | /* How far back to free. */ |
487 | struct partial_symtab *m_psymtab; | |
488 | }; | |
c9bf0622 | 489 | |
39298a5d TT |
490 | /* An implementation of quick_symbol_functions, specialized for |
491 | partial symbols. */ | |
492 | struct psymbol_functions : public quick_symbol_functions | |
493 | { | |
17d66340 TT |
494 | explicit psymbol_functions (const std::shared_ptr<psymtab_storage> &storage) |
495 | : m_partial_symtabs (storage) | |
496 | { | |
497 | } | |
498 | ||
eb36a3eb TT |
499 | psymbol_functions () |
500 | : m_partial_symtabs (new psymtab_storage) | |
501 | { | |
502 | } | |
503 | ||
39298a5d TT |
504 | bool has_symbols (struct objfile *objfile) override; |
505 | ||
fc4d5ebf AB |
506 | bool has_unexpanded_symtabs (struct objfile *objfile) override; |
507 | ||
39298a5d TT |
508 | struct symtab *find_last_source_symtab (struct objfile *objfile) override; |
509 | ||
510 | void forget_cached_source_info (struct objfile *objfile) override; | |
511 | ||
39298a5d TT |
512 | enum language lookup_global_symbol_language (struct objfile *objfile, |
513 | const char *name, | |
514 | domain_enum domain, | |
515 | bool *symbol_found_p) override; | |
516 | ||
4829711b | 517 | void print_stats (struct objfile *objfile, bool print_bcache) override; |
39298a5d TT |
518 | |
519 | void dump (struct objfile *objfile) override; | |
520 | ||
39298a5d TT |
521 | void expand_all_symtabs (struct objfile *objfile) override; |
522 | ||
0b7b2c2a | 523 | void expand_matching_symbols |
39298a5d TT |
524 | (struct objfile *, |
525 | const lookup_name_info &lookup_name, | |
526 | domain_enum domain, | |
527 | int global, | |
39298a5d TT |
528 | symbol_compare_ftype *ordered_compare) override; |
529 | ||
df35e626 | 530 | bool expand_symtabs_matching |
39298a5d TT |
531 | (struct objfile *objfile, |
532 | gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher, | |
533 | const lookup_name_info *lookup_name, | |
534 | gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher, | |
535 | gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify, | |
03a8ea51 | 536 | block_search_flags search_flags, |
3bfa51a7 | 537 | domain_enum domain, |
39298a5d TT |
538 | enum search_domain kind) override; |
539 | ||
540 | struct compunit_symtab *find_pc_sect_compunit_symtab | |
541 | (struct objfile *objfile, struct bound_minimal_symbol msymbol, | |
542 | CORE_ADDR pc, struct obj_section *section, int warn_if_readin) override; | |
543 | ||
544 | struct compunit_symtab *find_compunit_symtab_by_address | |
545 | (struct objfile *objfile, CORE_ADDR address) override; | |
546 | ||
547 | void map_symbol_filenames (struct objfile *objfile, | |
f4655dee TT |
548 | gdb::function_view<symbol_filename_ftype> fun, |
549 | bool need_fullname) override; | |
75336a5a TT |
550 | |
551 | void relocated () override | |
552 | { | |
553 | m_psymbol_map.clear (); | |
554 | } | |
555 | ||
3aa31ce7 TT |
556 | /* Ensure the partial symbols for OBJFILE have been loaded. Return |
557 | a range adapter for the psymtabs. */ | |
558 | psymtab_storage::partial_symtab_range require_partial_symbols | |
559 | (struct objfile *objfile); | |
560 | ||
561 | /* Return the partial symbol storage associated with this | |
562 | object. */ | |
563 | const std::shared_ptr<psymtab_storage> &get_partial_symtabs () const | |
564 | { | |
565 | return m_partial_symtabs; | |
566 | } | |
567 | ||
17d66340 TT |
568 | /* Replace the partial symbol table storage in this object with |
569 | SYMS. */ | |
570 | void set_partial_symtabs (const std::shared_ptr<psymtab_storage> &syms) | |
571 | { | |
572 | m_partial_symtabs = syms; | |
573 | } | |
574 | ||
3aa31ce7 TT |
575 | /* Find which partial symtab contains PC and SECTION. Return NULL if |
576 | none. We return the psymtab that contains a symbol whose address | |
577 | exactly matches PC, or, if we cannot find an exact match, the | |
578 | psymtab that contains a symbol whose address is closest to PC. */ | |
579 | ||
580 | struct partial_symtab *find_pc_sect_psymtab | |
581 | (struct objfile *objfile, | |
582 | CORE_ADDR pc, | |
583 | struct obj_section *section, | |
584 | struct bound_minimal_symbol msymbol); | |
585 | ||
75336a5a TT |
586 | private: |
587 | ||
caf8c1e5 TT |
588 | /* Count the number of partial symbols in *THIS. */ |
589 | int count_psyms (); | |
590 | ||
75336a5a TT |
591 | void fill_psymbol_map (struct objfile *objfile, |
592 | struct partial_symtab *psymtab, | |
593 | std::set<CORE_ADDR> *seen_addrs, | |
594 | const std::vector<partial_symbol *> &symbols); | |
595 | ||
17d66340 TT |
596 | /* Storage for the partial symbols. */ |
597 | std::shared_ptr<psymtab_storage> m_partial_symtabs; | |
598 | ||
75336a5a TT |
599 | /* Map symbol addresses to the partial symtab that defines the |
600 | object at that address. */ | |
601 | ||
602 | std::vector<std::pair<CORE_ADDR, partial_symtab *>> m_psymbol_map; | |
39298a5d TT |
603 | }; |
604 | ||
ccefe4c4 | 605 | #endif /* PSYMPRIV_H */ |