1 /* Private partial symbol table definitions. 2 3 Copyright (C) 2009-2019 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 #ifndef PSYMPRIV_H 21 #define PSYMPRIV_H 22 23 #include "psymtab.h" 24 #include "objfiles.h" 25 26 /* A partial_symbol records the name, domain, and address class of 27 symbols whose types we have not parsed yet. For functions, it also 28 contains their memory address, so we can find them from a PC value. 29 Each partial_symbol sits in a partial_symtab, all of which are chained 30 on a partial symtab list and which points to the corresponding 31 normal symtab once the partial_symtab has been referenced. */ 32 33 /* This structure is space critical. See space comments at the top of 34 symtab.h. */ 35 36 struct partial_symbol 37 { 38 /* Return the section for this partial symbol, or nullptr if no 39 section has been set. */ 40 struct obj_section *obj_section (struct objfile *objfile) const 41 { 42 if (ginfo.section >= 0) 43 return &objfile->sections[ginfo.section]; 44 return nullptr; 45 } 46 47 /* Return the unrelocated address of this partial symbol. */ 48 CORE_ADDR unrelocated_address () const 49 { 50 return ginfo.value.address; 51 } 52 53 /* Return the address of this partial symbol, relocated according to 54 the offsets provided in OBJFILE. */ 55 CORE_ADDR address (const struct objfile *objfile) const 56 { 57 return (ginfo.value.address 58 + ANOFFSET (objfile->section_offsets, ginfo.section)); 59 } 60 61 /* Set the address of this partial symbol. The address must be 62 unrelocated. */ 63 void set_unrelocated_address (CORE_ADDR addr) 64 { 65 ginfo.value.address = addr; 66 } 67 68 /* Note that partial_symbol does not derive from general_symbol_info 69 due to the bcache. See add_psymbol_to_bcache. */ 70 71 struct general_symbol_info ginfo; 72 73 /* Name space code. */ 74 75 ENUM_BITFIELD(domain_enum_tag) domain : SYMBOL_DOMAIN_BITS; 76 77 /* Address class (for info_symbols). Note that we don't allow 78 synthetic "aclass" values here at present, simply because there's 79 no need. */ 80 81 ENUM_BITFIELD(address_class) aclass : SYMBOL_ACLASS_BITS; 82 }; 83 84 /* A convenience enum to give names to some constants used when 85 searching psymtabs. This is internal to psymtab and should not be 86 used elsewhere. */ 87 88 enum psymtab_search_status 89 { 90 PST_NOT_SEARCHED, 91 PST_SEARCHED_AND_FOUND, 92 PST_SEARCHED_AND_NOT_FOUND 93 }; 94 95 /* Each source file that has not been fully read in is represented by 96 a partial_symtab. This contains the information on where in the 97 executable the debugging symbols for a specific file are, and a 98 list of names of global symbols which are located in this file. 99 They are all chained on partial symtab lists. 100 101 Even after the source file has been read into a symtab, the 102 partial_symtab remains around. They are allocated on an obstack, 103 objfile_obstack. */ 104 105 struct partial_symtab 106 { 107 /* Return the raw low text address of this partial_symtab. */ 108 CORE_ADDR raw_text_low () const 109 { 110 return m_text_low; 111 } 112 113 /* Return the raw high text address of this partial_symtab. */ 114 CORE_ADDR raw_text_high () const 115 { 116 return m_text_high; 117 } 118 119 /* Return the relocated low text address of this partial_symtab. */ 120 CORE_ADDR text_low (struct objfile *objfile) const 121 { 122 return m_text_low + ANOFFSET (objfile->section_offsets, 123 SECT_OFF_TEXT (objfile)); 124 } 125 126 /* Return the relocated high text address of this partial_symtab. */ 127 CORE_ADDR text_high (struct objfile *objfile) const 128 { 129 return m_text_high + ANOFFSET (objfile->section_offsets, 130 SECT_OFF_TEXT (objfile)); 131 } 132 133 /* Set the low text address of this partial_symtab. */ 134 void set_text_low (CORE_ADDR addr) 135 { 136 m_text_low = addr; 137 text_low_valid = 1; 138 } 139 140 /* Set the hight text address of this partial_symtab. */ 141 void set_text_high (CORE_ADDR addr) 142 { 143 m_text_high = addr; 144 text_high_valid = 1; 145 } 146 147 148 /* Chain of all existing partial symtabs. */ 149 150 struct partial_symtab *next; 151 152 /* Name of the source file which this partial_symtab defines, 153 or if the psymtab is anonymous then a descriptive name for 154 debugging purposes, or "". It must not be NULL. */ 155 156 const char *filename; 157 158 /* Full path of the source file. NULL if not known. */ 159 160 char *fullname; 161 162 /* Directory in which it was compiled, or NULL if we don't know. */ 163 164 const char *dirname; 165 166 /* Range of text addresses covered by this file; texthigh is the 167 beginning of the next section. Do not use if PSYMTABS_ADDRMAP_SUPPORTED 168 is set. Do not refer directly to these fields. Instead, use the 169 accessors. The validity of these fields is determined by the 170 text_low_valid and text_high_valid fields; these are located later 171 in this structure for better packing. */ 172 173 CORE_ADDR m_text_low; 174 CORE_ADDR m_text_high; 175 176 /* If NULL, this is an ordinary partial symbol table. 177 178 If non-NULL, this holds a single includer of this partial symbol 179 table, and this partial symbol table is a shared one. 180 181 A shared psymtab is one that is referenced by multiple other 182 psymtabs, and which conceptually has its contents directly 183 included in those. 184 185 Shared psymtabs have special semantics. When a search finds a 186 symbol in a shared table, we instead return one of the non-shared 187 tables that include this one. 188 189 A shared psymtabs can be referred to by other shared ones. 190 191 The psymtabs that refer to a shared psymtab will list the shared 192 psymtab in their 'dependencies' array. 193 194 In DWARF terms, a shared psymtab is a DW_TAG_partial_unit; but 195 of course using a name based on that would be too confusing, so 196 "shared" was chosen instead. 197 198 Only a single user is needed because, when expanding a shared 199 psymtab, we only need to expand its "canonical" non-shared user. 200 The choice of which one should be canonical is left to the 201 debuginfo reader; it can be arbitrary. */ 202 203 struct partial_symtab *user; 204 205 /* Array of pointers to all of the partial_symtab's which this one 206 depends on. Since this array can only be set to previous or 207 the current (?) psymtab, this dependency tree is guaranteed not 208 to have any loops. "depends on" means that symbols must be read 209 for the dependencies before being read for this psymtab; this is 210 for type references in stabs, where if foo.c includes foo.h, declarations 211 in foo.h may use type numbers defined in foo.c. For other debugging 212 formats there may be no need to use dependencies. */ 213 214 struct partial_symtab **dependencies; 215 216 int number_of_dependencies; 217 218 /* Global symbol list. This list will be sorted after readin to 219 improve access. Binary search will be the usual method of 220 finding a symbol within it. globals_offset is an integer offset 221 within global_psymbols[]. */ 222 223 int globals_offset; 224 int n_global_syms; 225 226 /* Static symbol list. This list will *not* be sorted after readin; 227 to find a symbol in it, exhaustive search must be used. This is 228 reasonable because searches through this list will eventually 229 lead to either the read in of a files symbols for real (assumed 230 to take a *lot* of time; check) or an error (and we don't care 231 how long errors take). This is an offset and size within 232 static_psymbols[]. */ 233 234 int statics_offset; 235 int n_static_syms; 236 237 /* Non-zero if the symtab corresponding to this psymtab has been 238 readin. This is located here so that this structure packs better 239 on 64-bit systems. */ 240 241 unsigned char readin; 242 243 /* True iff objfile->psymtabs_addrmap is properly populated for this 244 partial_symtab. For discontiguous overlapping psymtabs is the only usable 245 info in PSYMTABS_ADDRMAP. */ 246 247 unsigned char psymtabs_addrmap_supported; 248 249 /* True if the name of this partial symtab is not a source file name. */ 250 251 unsigned char anonymous; 252 253 /* A flag that is temporarily used when searching psymtabs. */ 254 255 ENUM_BITFIELD (psymtab_search_status) searched_flag : 2; 256 257 /* Validity of the m_text_low and m_text_high fields. */ 258 259 unsigned int text_low_valid : 1; 260 unsigned int text_high_valid : 1; 261 262 /* Pointer to compunit eventually allocated for this source file, 0 if 263 !readin or if we haven't looked for the symtab after it was readin. */ 264 265 struct compunit_symtab *compunit_symtab; 266 267 /* Pointer to function which will read in the symtab corresponding to 268 this psymtab. */ 269 270 void (*read_symtab) (struct partial_symtab *, struct objfile *); 271 272 /* Information that lets read_symtab() locate the part of the symbol table 273 that this psymtab corresponds to. This information is private to the 274 format-dependent symbol reading routines. For further detail examine 275 the various symbol reading modules. */ 276 277 void *read_symtab_private; 278 }; 279 280 /* Specify whether a partial psymbol should be allocated on the global 281 list or the static list. */ 282 283 enum class psymbol_placement 284 { 285 STATIC, 286 GLOBAL 287 }; 288 289 /* Add any kind of symbol to a partial_symbol vector. */ 290 291 extern void add_psymbol_to_list (const char *, int, 292 int, domain_enum, 293 enum address_class, 294 short /* section */, 295 enum psymbol_placement, 296 CORE_ADDR, 297 enum language, struct objfile *); 298 299 /* Initialize storage for partial symbols. If partial symbol storage 300 has already been initialized, this does nothing. TOTAL_SYMBOLS is 301 an estimate of how many symbols there will be. */ 302 303 extern void init_psymbol_list (struct objfile *objfile, int total_symbols); 304 305 extern struct partial_symtab *start_psymtab_common (struct objfile *, 306 const char *, CORE_ADDR); 307 308 extern void end_psymtab_common (struct objfile *, struct partial_symtab *); 309 310 /* Allocate a new partial symbol table associated with OBJFILE. 311 FILENAME (which must be non-NULL) is the filename of this partial 312 symbol table; it is copied into the appropriate storage. A new 313 partial symbol table is returned; aside from "next" and "filename", 314 its fields are initialized to zero. */ 315 316 extern struct partial_symtab *allocate_psymtab (const char *filename, 317 struct objfile *objfile) 318 ATTRIBUTE_NONNULL (1); 319 320 static inline void 321 discard_psymtab (struct objfile *objfile, struct partial_symtab *pst) 322 { 323 objfile->partial_symtabs->discard_psymtab (pst); 324 } 325 326 /* Used when recording partial symbol tables. On destruction, 327 discards any partial symbol tables that have been built. However, 328 the tables can be kept by calling the "keep" method. */ 329 class psymtab_discarder 330 { 331 public: 332 333 psymtab_discarder (struct objfile *objfile) 334 : m_objfile (objfile), 335 m_psymtab (objfile->partial_symtabs->psymtabs) 336 { 337 } 338 339 ~psymtab_discarder () 340 { 341 if (m_objfile != NULL) 342 m_objfile->partial_symtabs->discard_psymtabs_to (m_psymtab); 343 } 344 345 /* Keep any partial symbol tables that were built. */ 346 void keep () 347 { 348 m_objfile = NULL; 349 } 350 351 private: 352 353 /* The objfile. If NULL this serves as a sentinel to indicate that 354 the psymtabs should be kept. */ 355 struct objfile *m_objfile; 356 /* How far back to free. */ 357 struct partial_symtab *m_psymtab; 358 }; 359 360 #endif /* PSYMPRIV_H */ 361