]>
Commit | Line | Data |
---|---|---|
c906108c | 1 | /* Definitions for reading symbol files into GDB. |
3a6c3343 | 2 | |
3666a048 | 3 | Copyright (C) 1990-2021 Free Software Foundation, Inc. |
c906108c | 4 | |
c5aa993b | 5 | This file is part of GDB. |
c906108c | 6 | |
c5aa993b JM |
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 | |
a9762ec7 | 9 | the Free Software Foundation; either version 3 of the License, or |
c5aa993b | 10 | (at your option) any later version. |
c906108c | 11 | |
c5aa993b JM |
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. | |
c906108c | 16 | |
c5aa993b | 17 | You should have received a copy of the GNU General Public License |
a9762ec7 | 18 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
c906108c SS |
19 | |
20 | #if !defined (SYMFILE_H) | |
21 | #define SYMFILE_H | |
22 | ||
23 | /* This file requires that you first include "bfd.h". */ | |
16708cba | 24 | #include "symtab.h" |
48faced0 | 25 | #include "probe.h" |
b15cc25c PA |
26 | #include "symfile-add-flags.h" |
27 | #include "objfile-flags.h" | |
192b62ce | 28 | #include "gdb_bfd.h" |
268a13a5 | 29 | #include "gdbsupport/function-view.h" |
bb2a6777 | 30 | #include "target-section.h" |
9b99dcc8 | 31 | #include "quick-symbol.h" |
c906108c | 32 | |
63ca651f | 33 | /* Opaque declarations. */ |
0542c86d | 34 | struct target_section; |
da3331ec | 35 | struct objfile; |
1c772458 | 36 | struct obj_section; |
63ca651f | 37 | struct obstack; |
fe898f56 | 38 | struct block; |
55aa24fb SDJ |
39 | struct value; |
40 | struct frame_info; | |
41 | struct agent_expr; | |
42 | struct axs_value; | |
935676c9 | 43 | class probe; |
63ca651f | 44 | |
52059ffd TT |
45 | struct other_sections |
46 | { | |
37e136b1 TT |
47 | other_sections (CORE_ADDR addr_, std::string &&name_, int sectindex_) |
48 | : addr (addr_), | |
49 | name (std::move (name_)), | |
50 | sectindex (sectindex_) | |
51 | { | |
52 | } | |
53 | ||
54 | other_sections (other_sections &&other) = default; | |
55 | ||
56 | DISABLE_COPY_AND_ASSIGN (other_sections); | |
57 | ||
52059ffd | 58 | CORE_ADDR addr; |
37e136b1 | 59 | std::string name; |
52059ffd | 60 | |
d81a3eaf PT |
61 | /* SECTINDEX must be valid for associated BFD or set to -1. |
62 | See syms_from_objfile_1 for an exception to this rule. | |
63 | */ | |
52059ffd TT |
64 | int sectindex; |
65 | }; | |
66 | ||
62557bbc KB |
67 | /* Define an array of addresses to accommodate non-contiguous dynamic |
68 | loading of modules. This is for use when entering commands, so we | |
3a6c3343 AC |
69 | can keep track of the section names until we read the file and can |
70 | map them to bfd sections. This structure is also used by solib.c | |
71 | to communicate the section addresses in shared objects to | |
72 | symbol_file_add (). */ | |
73 | ||
37e136b1 | 74 | typedef std::vector<other_sections> section_addr_info; |
28c32713 JB |
75 | |
76 | /* A table listing the load segments in a symfile, and which segment | |
77 | each BFD section belongs to. */ | |
31d99776 DJ |
78 | struct symfile_segment_data |
79 | { | |
68b888ff SM |
80 | struct segment |
81 | { | |
82 | segment (CORE_ADDR base, CORE_ADDR size) | |
83 | : base (base), size (size) | |
84 | {} | |
85 | ||
86 | /* The original base address the segment. */ | |
87 | CORE_ADDR base; | |
88 | ||
89 | /* The memory size of the segment. */ | |
90 | CORE_ADDR size; | |
91 | }; | |
92 | ||
68b888ff | 93 | /* The segments present in this file. If there are |
31d99776 DJ |
94 | two, the text segment is the first one and the data segment |
95 | is the second one. */ | |
68b888ff | 96 | std::vector<segment> segments; |
31d99776 | 97 | |
68b888ff SM |
98 | /* This is an array of entries recording which segment contains each BFD |
99 | section. SEGMENT_INFO[I] is S+1 if the I'th BFD section belongs to segment | |
28c32713 | 100 | S, or zero if it is not in any segment. */ |
9005fbbb | 101 | std::vector<int> segment_info; |
31d99776 DJ |
102 | }; |
103 | ||
62982abd SM |
104 | using symfile_segment_data_up = std::unique_ptr<symfile_segment_data>; |
105 | ||
55aa24fb SDJ |
106 | /* Structure of functions used for probe support. If one of these functions |
107 | is provided, all must be. */ | |
108 | ||
109 | struct sym_probe_fns | |
110 | { | |
aaa63a31 | 111 | /* If non-NULL, return a reference to vector of probe objects. */ |
814cf43a TT |
112 | const std::vector<std::unique_ptr<probe>> &(*sym_get_probes) |
113 | (struct objfile *); | |
55aa24fb SDJ |
114 | }; |
115 | ||
c906108c SS |
116 | /* Structure to keep track of symbol reading functions for various |
117 | object file types. */ | |
118 | ||
c5aa993b | 119 | struct sym_fns |
3a6c3343 | 120 | { |
3a6c3343 AC |
121 | /* Initializes anything that is global to the entire symbol table. |
122 | It is called during symbol_file_add, when we begin debugging an | |
123 | entirely new program. */ | |
c906108c | 124 | |
3a6c3343 | 125 | void (*sym_new_init) (struct objfile *); |
c906108c | 126 | |
3a6c3343 AC |
127 | /* Reads any initial information from a symbol file, and initializes |
128 | the struct sym_fns SF in preparation for sym_read(). It is | |
129 | called every time we read a symbol file for any reason. */ | |
c906108c | 130 | |
3a6c3343 | 131 | void (*sym_init) (struct objfile *); |
c906108c | 132 | |
f4352531 | 133 | /* sym_read (objfile, symfile_flags) Reads a symbol file into a psymtab |
3a6c3343 | 134 | (or possibly a symtab). OBJFILE is the objfile struct for the |
f4352531 TG |
135 | file we are reading. SYMFILE_FLAGS are the flags passed to |
136 | symbol_file_add & co. */ | |
c906108c | 137 | |
b15cc25c | 138 | void (*sym_read) (struct objfile *, symfile_add_flags); |
c906108c | 139 | |
3e03848b JK |
140 | /* Read the partial symbols for an objfile. This may be NULL, in which case |
141 | gdb has to check other ways if this objfile has any symbols. This may | |
142 | only be non-NULL if the objfile actually does have debuginfo available. | |
143 | */ | |
b11896a5 TT |
144 | |
145 | void (*sym_read_psymbols) (struct objfile *); | |
146 | ||
3a6c3343 AC |
147 | /* Called when we are finished with an objfile. Should do all |
148 | cleanup that is specific to the object file format for the | |
149 | particular objfile. */ | |
c906108c | 150 | |
3a6c3343 | 151 | void (*sym_finish) (struct objfile *); |
c906108c | 152 | |
db7a9bcd | 153 | |
3a6c3343 | 154 | /* This function produces a file-dependent section_offsets |
db7a9bcd SM |
155 | structure, allocated in the objfile's storage. |
156 | ||
157 | The section_addr_info structure contains the offset of loadable and | |
158 | allocated sections, relative to the absolute offsets found in the BFD. */ | |
c906108c | 159 | |
37e136b1 | 160 | void (*sym_offsets) (struct objfile *, const section_addr_info &); |
c906108c | 161 | |
31d99776 DJ |
162 | /* This function produces a format-independent description of |
163 | the segments of ABFD. Each segment is a unit of the file | |
164 | which may be relocated independently. */ | |
165 | ||
62982abd | 166 | symfile_segment_data_up (*sym_segments) (bfd *abfd); |
31d99776 | 167 | |
c295b2e5 JB |
168 | /* This function should read the linetable from the objfile when |
169 | the line table cannot be read while processing the debugging | |
170 | information. */ | |
ac8035ab | 171 | |
f56ce883 | 172 | void (*sym_read_linetable) (struct objfile *); |
c295b2e5 | 173 | |
ac8035ab TG |
174 | /* Relocate the contents of a debug section SECTP. The |
175 | contents are stored in BUF if it is non-NULL, or returned in a | |
176 | malloc'd buffer otherwise. */ | |
177 | ||
178 | bfd_byte *(*sym_relocate) (struct objfile *, asection *sectp, bfd_byte *buf); | |
179 | ||
55aa24fb SDJ |
180 | /* If non-NULL, this objfile has probe support, and all the probe |
181 | functions referred to here will be non-NULL. */ | |
182 | const struct sym_probe_fns *sym_probe_fns; | |
3a6c3343 | 183 | }; |
c906108c | 184 | |
37e136b1 | 185 | extern section_addr_info |
3e43a32a | 186 | build_section_addr_info_from_objfile (const struct objfile *objfile); |
567995e1 | 187 | |
75242ef4 | 188 | extern void relative_addr_info_to_section_offsets |
6a053cb1 | 189 | (section_offsets §ion_offsets, const section_addr_info &addrs); |
75242ef4 | 190 | |
37e136b1 | 191 | extern void addr_info_make_relative (section_addr_info *addrs, |
75242ef4 JK |
192 | bfd *abfd); |
193 | ||
c906108c SS |
194 | /* The default version of sym_fns.sym_offsets for readers that don't |
195 | do anything special. */ | |
196 | ||
570b8f7c | 197 | extern void default_symfile_offsets (struct objfile *objfile, |
37e136b1 | 198 | const section_addr_info &); |
c906108c | 199 | |
31d99776 DJ |
200 | /* The default version of sym_fns.sym_segments for readers that don't |
201 | do anything special. */ | |
202 | ||
62982abd | 203 | extern symfile_segment_data_up default_symfile_segments (bfd *abfd); |
c906108c | 204 | |
ac8035ab TG |
205 | /* The default version of sym_fns.sym_relocate for readers that don't |
206 | do anything special. */ | |
207 | ||
208 | extern bfd_byte *default_symfile_relocate (struct objfile *objfile, | |
dda83cd7 | 209 | asection *sectp, bfd_byte *buf); |
ac8035ab | 210 | |
43f3e411 | 211 | extern struct symtab *allocate_symtab (struct compunit_symtab *, const char *) |
4e04028d | 212 | ATTRIBUTE_NONNULL (1); |
c906108c | 213 | |
43f3e411 DE |
214 | extern struct compunit_symtab *allocate_compunit_symtab (struct objfile *, |
215 | const char *) | |
216 | ATTRIBUTE_NONNULL (1); | |
217 | ||
218 | extern void add_compunit_symtab_to_objfile (struct compunit_symtab *cu); | |
219 | ||
c256e171 | 220 | extern void add_symtab_fns (enum bfd_flavour flavour, const struct sym_fns *); |
c906108c | 221 | |
b15cc25c | 222 | extern void clear_symtab_users (symfile_add_flags add_flags); |
f176c4b5 DE |
223 | |
224 | extern enum language deduce_language_from_filename (const char *); | |
225 | ||
56618e20 TT |
226 | /* Map the filename extension EXT to the language LANG. Any previous |
227 | association of EXT will be removed. EXT will be copied by this | |
228 | function. */ | |
229 | extern void add_filename_language (const char *ext, enum language lang); | |
230 | ||
b15cc25c | 231 | extern struct objfile *symbol_file_add (const char *, symfile_add_flags, |
37e136b1 | 232 | section_addr_info *, objfile_flags); |
7eedccfa | 233 | |
b15cc25c | 234 | extern struct objfile *symbol_file_add_from_bfd (bfd *, const char *, symfile_add_flags, |
37e136b1 | 235 | section_addr_info *, |
dda83cd7 | 236 | objfile_flags, struct objfile *parent); |
eb4556d7 | 237 | |
b15cc25c | 238 | extern void symbol_file_add_separate (bfd *, const char *, symfile_add_flags, |
24ba069a | 239 | struct objfile *); |
9cce227f | 240 | |
a8dbfd58 | 241 | extern std::string find_separate_debug_file_by_debuglink (struct objfile *); |
9cce227f | 242 | |
3a6c3343 AC |
243 | /* Build (allocate and populate) a section_addr_info struct from an |
244 | existing section table. */ | |
62557bbc | 245 | |
37e136b1 | 246 | extern section_addr_info |
bb2a6777 | 247 | build_section_addr_info_from_section_table (const target_section_table &table); |
62557bbc | 248 | |
c906108c SS |
249 | /* Variables */ |
250 | ||
491144b5 | 251 | /* If true, shared library symbols will be added automatically |
b7209cb4 FF |
252 | when the inferior is created, new libraries are loaded, or when |
253 | attaching to the inferior. This is almost always what users will | |
254 | want to have happen; but for very large programs, the startup time | |
255 | will be excessive, and so if this is a problem, the user can clear | |
256 | this flag and then add the shared library symbols as needed. Note | |
257 | that there is a potential for confusion, since if the shared | |
258 | library symbols are not loaded, commands like "info fun" will *not* | |
3a6c3343 | 259 | report all the functions that are actually present. */ |
c906108c | 260 | |
491144b5 | 261 | extern bool auto_solib_add; |
c906108c | 262 | |
c906108c SS |
263 | /* From symfile.c */ |
264 | ||
8b60591b JB |
265 | extern void set_initial_language (void); |
266 | ||
192b62ce | 267 | extern gdb_bfd_ref_ptr symfile_bfd_open (const char *); |
c906108c | 268 | |
a121b7c1 | 269 | extern int get_section_index (struct objfile *, const char *); |
e2f6d8e5 | 270 | |
770e7fc7 DE |
271 | extern int print_symbol_loading_p (int from_tty, int mainline, int full); |
272 | ||
c906108c | 273 | /* Utility functions for overlay sections: */ |
3a6c3343 AC |
274 | extern enum overlay_debugging_state |
275 | { | |
276 | ovly_off, | |
277 | ovly_on, | |
d874f1e2 MS |
278 | ovly_auto |
279 | } overlay_debugging; | |
c906108c SS |
280 | extern int overlay_cache_invalid; |
281 | ||
3a6c3343 | 282 | /* Return the "mapped" overlay section containing the PC. */ |
714835d5 | 283 | extern struct obj_section *find_pc_mapped_section (CORE_ADDR); |
c906108c | 284 | |
3a6c3343 AC |
285 | /* Return any overlay section containing the PC (even in its LMA |
286 | region). */ | |
714835d5 | 287 | extern struct obj_section *find_pc_overlay (CORE_ADDR); |
c906108c | 288 | |
3a6c3343 | 289 | /* Return true if the section is an overlay. */ |
714835d5 | 290 | extern int section_is_overlay (struct obj_section *); |
c906108c | 291 | |
3a6c3343 | 292 | /* Return true if the overlay section is currently "mapped". */ |
714835d5 | 293 | extern int section_is_mapped (struct obj_section *); |
c906108c | 294 | |
3a6c3343 | 295 | /* Return true if pc belongs to section's VMA. */ |
714835d5 | 296 | extern CORE_ADDR pc_in_mapped_range (CORE_ADDR, struct obj_section *); |
c906108c | 297 | |
3a6c3343 | 298 | /* Return true if pc belongs to section's LMA. */ |
714835d5 | 299 | extern CORE_ADDR pc_in_unmapped_range (CORE_ADDR, struct obj_section *); |
c906108c | 300 | |
3a6c3343 | 301 | /* Map an address from a section's LMA to its VMA. */ |
714835d5 | 302 | extern CORE_ADDR overlay_mapped_address (CORE_ADDR, struct obj_section *); |
c906108c | 303 | |
3a6c3343 | 304 | /* Map an address from a section's VMA to its LMA. */ |
714835d5 | 305 | extern CORE_ADDR overlay_unmapped_address (CORE_ADDR, struct obj_section *); |
c906108c | 306 | |
3a6c3343 | 307 | /* Convert an address in an overlay section (force into VMA range). */ |
714835d5 | 308 | extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *); |
c906108c | 309 | |
3a6c3343 | 310 | /* Load symbols from a file. */ |
ecf45d2c SL |
311 | extern void symbol_file_add_main (const char *args, |
312 | symfile_add_flags add_flags); | |
1adeb98a | 313 | |
3a6c3343 | 314 | /* Clear GDB symbol tables. */ |
1adeb98a FN |
315 | extern void symbol_file_clear (int from_tty); |
316 | ||
1c772458 UW |
317 | /* Default overlay update function. */ |
318 | extern void simple_overlay_update (struct obj_section *); | |
319 | ||
ac8035ab TG |
320 | extern bfd_byte *symfile_relocate_debug_section (struct objfile *, asection *, |
321 | bfd_byte *); | |
086df311 | 322 | |
31d99776 | 323 | extern int symfile_map_offsets_to_segments (bfd *, |
3189cb12 | 324 | const struct symfile_segment_data *, |
6a053cb1 | 325 | section_offsets &, |
31d99776 | 326 | int, const CORE_ADDR *); |
62982abd | 327 | symfile_segment_data_up get_symfile_segment_data (bfd *abfd); |
31d99776 | 328 | |
c83dd867 | 329 | extern scoped_restore_tmpl<int> increment_reading_symtab (void); |
ccefe4c4 | 330 | |
14bc53a8 PA |
331 | void expand_symtabs_matching |
332 | (gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher, | |
b5ec771e | 333 | const lookup_name_info &lookup_name, |
14bc53a8 PA |
334 | gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher, |
335 | gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify, | |
336 | enum search_domain kind); | |
540c2971 | 337 | |
bb4142cf DE |
338 | void map_symbol_filenames (symbol_filename_ftype *fun, void *data, |
339 | int need_fullname); | |
540c2971 | 340 | |
854f6088 SM |
341 | /* Target-agnostic function to load the sections of an executable into memory. |
342 | ||
343 | ARGS should be in the form "EXECUTABLE [OFFSET]", where OFFSET is an | |
344 | optional offset to apply to each section. */ | |
345 | extern void generic_load (const char *args, int from_tty); | |
346 | ||
608e2dbb TT |
347 | /* From minidebug.c. */ |
348 | ||
192b62ce | 349 | extern gdb_bfd_ref_ptr find_separate_debug_file_in_section (struct objfile *); |
608e2dbb | 350 | |
c4dcb155 SM |
351 | /* True if we are printing debug output about separate debug info files. */ |
352 | ||
491144b5 | 353 | extern bool separate_debug_file_debug; |
c4dcb155 | 354 | |
fe7a351a SM |
355 | /* Read full symbols immediately. */ |
356 | ||
357 | extern int readnow_symbol_files; | |
358 | ||
359 | /* Never read full symbols. */ | |
360 | ||
361 | extern int readnever_symbol_files; | |
362 | ||
c5aa993b | 363 | #endif /* !defined(SYMFILE_H) */ |