| 1 | /* Definitions for reading symbol files into GDB. |
| 2 | |
| 3 | Copyright (C) 1990-2021 Free Software Foundation, Inc. |
| 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 | #if !defined (SYMFILE_H) |
| 21 | #define SYMFILE_H |
| 22 | |
| 23 | /* This file requires that you first include "bfd.h". */ |
| 24 | #include "symtab.h" |
| 25 | #include "probe.h" |
| 26 | #include "symfile-add-flags.h" |
| 27 | #include "objfile-flags.h" |
| 28 | #include "gdb_bfd.h" |
| 29 | #include "gdbsupport/function-view.h" |
| 30 | #include "target-section.h" |
| 31 | #include "quick-symbol.h" |
| 32 | |
| 33 | /* Opaque declarations. */ |
| 34 | struct target_section; |
| 35 | struct objfile; |
| 36 | struct obj_section; |
| 37 | struct obstack; |
| 38 | struct block; |
| 39 | struct value; |
| 40 | struct frame_info; |
| 41 | struct agent_expr; |
| 42 | struct axs_value; |
| 43 | class probe; |
| 44 | |
| 45 | struct other_sections |
| 46 | { |
| 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 | |
| 58 | CORE_ADDR addr; |
| 59 | std::string name; |
| 60 | |
| 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 | */ |
| 64 | int sectindex; |
| 65 | }; |
| 66 | |
| 67 | /* Define an array of addresses to accommodate non-contiguous dynamic |
| 68 | loading of modules. This is for use when entering commands, so we |
| 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 | |
| 74 | typedef std::vector<other_sections> section_addr_info; |
| 75 | |
| 76 | /* A table listing the load segments in a symfile, and which segment |
| 77 | each BFD section belongs to. */ |
| 78 | struct symfile_segment_data |
| 79 | { |
| 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 | |
| 93 | /* The segments present in this file. If there are |
| 94 | two, the text segment is the first one and the data segment |
| 95 | is the second one. */ |
| 96 | std::vector<segment> segments; |
| 97 | |
| 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 |
| 100 | S, or zero if it is not in any segment. */ |
| 101 | std::vector<int> segment_info; |
| 102 | }; |
| 103 | |
| 104 | using symfile_segment_data_up = std::unique_ptr<symfile_segment_data>; |
| 105 | |
| 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 | { |
| 111 | /* If non-NULL, return a reference to vector of probe objects. */ |
| 112 | const std::vector<std::unique_ptr<probe>> &(*sym_get_probes) |
| 113 | (struct objfile *); |
| 114 | }; |
| 115 | |
| 116 | /* Structure to keep track of symbol reading functions for various |
| 117 | object file types. */ |
| 118 | |
| 119 | struct sym_fns |
| 120 | { |
| 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. */ |
| 124 | |
| 125 | void (*sym_new_init) (struct objfile *); |
| 126 | |
| 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. */ |
| 130 | |
| 131 | void (*sym_init) (struct objfile *); |
| 132 | |
| 133 | /* sym_read (objfile, symfile_flags) Reads a symbol file into a psymtab |
| 134 | (or possibly a symtab). OBJFILE is the objfile struct for the |
| 135 | file we are reading. SYMFILE_FLAGS are the flags passed to |
| 136 | symbol_file_add & co. */ |
| 137 | |
| 138 | void (*sym_read) (struct objfile *, symfile_add_flags); |
| 139 | |
| 140 | /* Called when we are finished with an objfile. Should do all |
| 141 | cleanup that is specific to the object file format for the |
| 142 | particular objfile. */ |
| 143 | |
| 144 | void (*sym_finish) (struct objfile *); |
| 145 | |
| 146 | |
| 147 | /* This function produces a file-dependent section_offsets |
| 148 | structure, allocated in the objfile's storage. |
| 149 | |
| 150 | The section_addr_info structure contains the offset of loadable and |
| 151 | allocated sections, relative to the absolute offsets found in the BFD. */ |
| 152 | |
| 153 | void (*sym_offsets) (struct objfile *, const section_addr_info &); |
| 154 | |
| 155 | /* This function produces a format-independent description of |
| 156 | the segments of ABFD. Each segment is a unit of the file |
| 157 | which may be relocated independently. */ |
| 158 | |
| 159 | symfile_segment_data_up (*sym_segments) (bfd *abfd); |
| 160 | |
| 161 | /* This function should read the linetable from the objfile when |
| 162 | the line table cannot be read while processing the debugging |
| 163 | information. */ |
| 164 | |
| 165 | void (*sym_read_linetable) (struct objfile *); |
| 166 | |
| 167 | /* Relocate the contents of a debug section SECTP. The |
| 168 | contents are stored in BUF if it is non-NULL, or returned in a |
| 169 | malloc'd buffer otherwise. */ |
| 170 | |
| 171 | bfd_byte *(*sym_relocate) (struct objfile *, asection *sectp, bfd_byte *buf); |
| 172 | |
| 173 | /* If non-NULL, this objfile has probe support, and all the probe |
| 174 | functions referred to here will be non-NULL. */ |
| 175 | const struct sym_probe_fns *sym_probe_fns; |
| 176 | }; |
| 177 | |
| 178 | extern section_addr_info |
| 179 | build_section_addr_info_from_objfile (const struct objfile *objfile); |
| 180 | |
| 181 | extern void relative_addr_info_to_section_offsets |
| 182 | (section_offsets §ion_offsets, const section_addr_info &addrs); |
| 183 | |
| 184 | extern void addr_info_make_relative (section_addr_info *addrs, |
| 185 | bfd *abfd); |
| 186 | |
| 187 | /* The default version of sym_fns.sym_offsets for readers that don't |
| 188 | do anything special. */ |
| 189 | |
| 190 | extern void default_symfile_offsets (struct objfile *objfile, |
| 191 | const section_addr_info &); |
| 192 | |
| 193 | /* The default version of sym_fns.sym_segments for readers that don't |
| 194 | do anything special. */ |
| 195 | |
| 196 | extern symfile_segment_data_up default_symfile_segments (bfd *abfd); |
| 197 | |
| 198 | /* The default version of sym_fns.sym_relocate for readers that don't |
| 199 | do anything special. */ |
| 200 | |
| 201 | extern bfd_byte *default_symfile_relocate (struct objfile *objfile, |
| 202 | asection *sectp, bfd_byte *buf); |
| 203 | |
| 204 | extern struct symtab *allocate_symtab (struct compunit_symtab *, const char *) |
| 205 | ATTRIBUTE_NONNULL (1); |
| 206 | |
| 207 | extern struct compunit_symtab *allocate_compunit_symtab (struct objfile *, |
| 208 | const char *) |
| 209 | ATTRIBUTE_NONNULL (1); |
| 210 | |
| 211 | extern void add_compunit_symtab_to_objfile (struct compunit_symtab *cu); |
| 212 | |
| 213 | extern void add_symtab_fns (enum bfd_flavour flavour, const struct sym_fns *); |
| 214 | |
| 215 | extern void clear_symtab_users (symfile_add_flags add_flags); |
| 216 | |
| 217 | extern enum language deduce_language_from_filename (const char *); |
| 218 | |
| 219 | /* Map the filename extension EXT to the language LANG. Any previous |
| 220 | association of EXT will be removed. EXT will be copied by this |
| 221 | function. */ |
| 222 | extern void add_filename_language (const char *ext, enum language lang); |
| 223 | |
| 224 | extern struct objfile *symbol_file_add (const char *, symfile_add_flags, |
| 225 | section_addr_info *, objfile_flags); |
| 226 | |
| 227 | extern struct objfile *symbol_file_add_from_bfd (bfd *, const char *, symfile_add_flags, |
| 228 | section_addr_info *, |
| 229 | objfile_flags, struct objfile *parent); |
| 230 | |
| 231 | extern void symbol_file_add_separate (bfd *, const char *, symfile_add_flags, |
| 232 | struct objfile *); |
| 233 | |
| 234 | extern std::string find_separate_debug_file_by_debuglink (struct objfile *); |
| 235 | |
| 236 | /* Build (allocate and populate) a section_addr_info struct from an |
| 237 | existing section table. */ |
| 238 | |
| 239 | extern section_addr_info |
| 240 | build_section_addr_info_from_section_table (const target_section_table &table); |
| 241 | |
| 242 | /* Variables */ |
| 243 | |
| 244 | /* If true, shared library symbols will be added automatically |
| 245 | when the inferior is created, new libraries are loaded, or when |
| 246 | attaching to the inferior. This is almost always what users will |
| 247 | want to have happen; but for very large programs, the startup time |
| 248 | will be excessive, and so if this is a problem, the user can clear |
| 249 | this flag and then add the shared library symbols as needed. Note |
| 250 | that there is a potential for confusion, since if the shared |
| 251 | library symbols are not loaded, commands like "info fun" will *not* |
| 252 | report all the functions that are actually present. */ |
| 253 | |
| 254 | extern bool auto_solib_add; |
| 255 | |
| 256 | /* From symfile.c */ |
| 257 | |
| 258 | extern void set_initial_language (void); |
| 259 | |
| 260 | extern gdb_bfd_ref_ptr symfile_bfd_open (const char *); |
| 261 | |
| 262 | extern int get_section_index (struct objfile *, const char *); |
| 263 | |
| 264 | extern int print_symbol_loading_p (int from_tty, int mainline, int full); |
| 265 | |
| 266 | /* Utility functions for overlay sections: */ |
| 267 | extern enum overlay_debugging_state |
| 268 | { |
| 269 | ovly_off, |
| 270 | ovly_on, |
| 271 | ovly_auto |
| 272 | } overlay_debugging; |
| 273 | extern int overlay_cache_invalid; |
| 274 | |
| 275 | /* Return the "mapped" overlay section containing the PC. */ |
| 276 | extern struct obj_section *find_pc_mapped_section (CORE_ADDR); |
| 277 | |
| 278 | /* Return any overlay section containing the PC (even in its LMA |
| 279 | region). */ |
| 280 | extern struct obj_section *find_pc_overlay (CORE_ADDR); |
| 281 | |
| 282 | /* Return true if the section is an overlay. */ |
| 283 | extern int section_is_overlay (struct obj_section *); |
| 284 | |
| 285 | /* Return true if the overlay section is currently "mapped". */ |
| 286 | extern int section_is_mapped (struct obj_section *); |
| 287 | |
| 288 | /* Return true if pc belongs to section's VMA. */ |
| 289 | extern CORE_ADDR pc_in_mapped_range (CORE_ADDR, struct obj_section *); |
| 290 | |
| 291 | /* Return true if pc belongs to section's LMA. */ |
| 292 | extern CORE_ADDR pc_in_unmapped_range (CORE_ADDR, struct obj_section *); |
| 293 | |
| 294 | /* Map an address from a section's LMA to its VMA. */ |
| 295 | extern CORE_ADDR overlay_mapped_address (CORE_ADDR, struct obj_section *); |
| 296 | |
| 297 | /* Map an address from a section's VMA to its LMA. */ |
| 298 | extern CORE_ADDR overlay_unmapped_address (CORE_ADDR, struct obj_section *); |
| 299 | |
| 300 | /* Convert an address in an overlay section (force into VMA range). */ |
| 301 | extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *); |
| 302 | |
| 303 | /* Load symbols from a file. */ |
| 304 | extern void symbol_file_add_main (const char *args, |
| 305 | symfile_add_flags add_flags); |
| 306 | |
| 307 | /* Clear GDB symbol tables. */ |
| 308 | extern void symbol_file_clear (int from_tty); |
| 309 | |
| 310 | /* Default overlay update function. */ |
| 311 | extern void simple_overlay_update (struct obj_section *); |
| 312 | |
| 313 | extern bfd_byte *symfile_relocate_debug_section (struct objfile *, asection *, |
| 314 | bfd_byte *); |
| 315 | |
| 316 | extern int symfile_map_offsets_to_segments (bfd *, |
| 317 | const struct symfile_segment_data *, |
| 318 | section_offsets &, |
| 319 | int, const CORE_ADDR *); |
| 320 | symfile_segment_data_up get_symfile_segment_data (bfd *abfd); |
| 321 | |
| 322 | extern scoped_restore_tmpl<int> increment_reading_symtab (void); |
| 323 | |
| 324 | bool expand_symtabs_matching |
| 325 | (gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher, |
| 326 | const lookup_name_info &lookup_name, |
| 327 | gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher, |
| 328 | gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify, |
| 329 | block_search_flags search_flags, |
| 330 | enum search_domain kind); |
| 331 | |
| 332 | void map_symbol_filenames (gdb::function_view<symbol_filename_ftype> fun, |
| 333 | bool need_fullname); |
| 334 | |
| 335 | /* Target-agnostic function to load the sections of an executable into memory. |
| 336 | |
| 337 | ARGS should be in the form "EXECUTABLE [OFFSET]", where OFFSET is an |
| 338 | optional offset to apply to each section. */ |
| 339 | extern void generic_load (const char *args, int from_tty); |
| 340 | |
| 341 | /* From minidebug.c. */ |
| 342 | |
| 343 | extern gdb_bfd_ref_ptr find_separate_debug_file_in_section (struct objfile *); |
| 344 | |
| 345 | /* True if we are printing debug output about separate debug info files. */ |
| 346 | |
| 347 | extern bool separate_debug_file_debug; |
| 348 | |
| 349 | /* Read full symbols immediately. */ |
| 350 | |
| 351 | extern int readnow_symbol_files; |
| 352 | |
| 353 | /* Never read full symbols. */ |
| 354 | |
| 355 | extern int readnever_symbol_files; |
| 356 | |
| 357 | #endif /* !defined(SYMFILE_H) */ |