1 /* Legacy support routines for building symbol tables in GDB's internal format. 2 Copyright (C) 1986-2023 Free Software Foundation, Inc. 3 4 This file is part of GDB. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19 #include "defs.h" 20 #include "buildsym-legacy.h" 21 #include "symtab.h" 22 23 /* The work-in-progress of the compunit we are building. 24 This is created first, before any subfiles by start_compunit_symtab. */ 25 26 static struct buildsym_compunit *buildsym_compunit; 27 28 void 29 record_debugformat (const char *format) 30 { 31 buildsym_compunit->record_debugformat (format); 32 } 33 34 void 35 record_producer (const char *producer) 36 { 37 buildsym_compunit->record_producer (producer); 38 } 39 40 41 42 /* See buildsym.h. */ 43 44 void 45 set_last_source_file (const char *name) 46 { 47 gdb_assert (buildsym_compunit != nullptr || name == nullptr); 48 if (buildsym_compunit != nullptr) 49 buildsym_compunit->set_last_source_file (name); 50 } 51 52 /* See buildsym.h. */ 53 54 const char * 55 get_last_source_file () 56 { 57 if (buildsym_compunit == nullptr) 58 return nullptr; 59 return buildsym_compunit->get_last_source_file (); 60 } 61 62 /* See buildsym.h. */ 63 64 void 65 set_last_source_start_addr (CORE_ADDR addr) 66 { 67 gdb_assert (buildsym_compunit != nullptr); 68 buildsym_compunit->set_last_source_start_addr (addr); 69 } 70 71 /* See buildsym.h. */ 72 73 CORE_ADDR 74 get_last_source_start_addr () 75 { 76 gdb_assert (buildsym_compunit != nullptr); 77 return buildsym_compunit->get_last_source_start_addr (); 78 } 79 80 /* See buildsym.h. */ 81 82 bool 83 outermost_context_p () 84 { 85 gdb_assert (buildsym_compunit != nullptr); 86 return buildsym_compunit->outermost_context_p (); 87 } 88 89 /* See buildsym.h. */ 90 91 int 92 get_context_stack_depth () 93 { 94 gdb_assert (buildsym_compunit != nullptr); 95 return buildsym_compunit->get_context_stack_depth (); 96 } 97 98 /* See buildsym.h. */ 99 100 struct subfile * 101 get_current_subfile () 102 { 103 gdb_assert (buildsym_compunit != nullptr); 104 return buildsym_compunit->get_current_subfile (); 105 } 106 107 /* See buildsym.h. */ 108 109 struct pending ** 110 get_local_symbols () 111 { 112 gdb_assert (buildsym_compunit != nullptr); 113 return buildsym_compunit->get_local_symbols (); 114 } 115 116 /* See buildsym.h. */ 117 118 struct pending ** 119 get_file_symbols () 120 { 121 gdb_assert (buildsym_compunit != nullptr); 122 return buildsym_compunit->get_file_symbols (); 123 } 124 125 /* See buildsym.h. */ 126 127 struct pending ** 128 get_global_symbols () 129 { 130 gdb_assert (buildsym_compunit != nullptr); 131 return buildsym_compunit->get_global_symbols (); 132 } 133 134 void 135 start_subfile (const char *name) 136 { 137 gdb_assert (buildsym_compunit != nullptr); 138 buildsym_compunit->start_subfile (name); 139 } 140 141 void 142 patch_subfile_names (struct subfile *subfile, const char *name) 143 { 144 gdb_assert (buildsym_compunit != nullptr); 145 buildsym_compunit->patch_subfile_names (subfile, name); 146 } 147 148 void 149 push_subfile () 150 { 151 gdb_assert (buildsym_compunit != nullptr); 152 buildsym_compunit->push_subfile (); 153 } 154 155 const char * 156 pop_subfile () 157 { 158 gdb_assert (buildsym_compunit != nullptr); 159 return buildsym_compunit->pop_subfile (); 160 } 161 162 /* Delete the buildsym compunit. */ 163 164 static void 165 free_buildsym_compunit (void) 166 { 167 if (buildsym_compunit == NULL) 168 return; 169 delete buildsym_compunit; 170 buildsym_compunit = NULL; 171 } 172 173 struct compunit_symtab * 174 end_compunit_symtab (CORE_ADDR end_addr, int section) 175 { 176 gdb_assert (buildsym_compunit != nullptr); 177 struct compunit_symtab *result 178 = buildsym_compunit->end_compunit_symtab (end_addr, section); 179 free_buildsym_compunit (); 180 return result; 181 } 182 183 struct context_stack * 184 push_context (int desc, CORE_ADDR valu) 185 { 186 gdb_assert (buildsym_compunit != nullptr); 187 return buildsym_compunit->push_context (desc, valu); 188 } 189 190 struct context_stack 191 pop_context () 192 { 193 gdb_assert (buildsym_compunit != nullptr); 194 return buildsym_compunit->pop_context (); 195 } 196 197 struct block * 198 finish_block (struct symbol *symbol, struct pending_block *old_blocks, 199 const struct dynamic_prop *static_link, 200 CORE_ADDR start, CORE_ADDR end) 201 { 202 gdb_assert (buildsym_compunit != nullptr); 203 return buildsym_compunit->finish_block (symbol, old_blocks, static_link, 204 start, end); 205 } 206 207 void 208 record_line (struct subfile *subfile, int line, CORE_ADDR pc) 209 { 210 gdb_assert (buildsym_compunit != nullptr); 211 /* Assume every line entry is a statement start, that is a good place to 212 put a breakpoint for that line number. */ 213 buildsym_compunit->record_line (subfile, line, pc, LEF_IS_STMT); 214 } 215 216 /* Start a new compunit_symtab for a new source file in OBJFILE. Called, for 217 example, when a stabs symbol of type N_SO is seen, or when a DWARF 218 DW_TAG_compile_unit DIE is seen. It indicates the start of data for one 219 original source file. 220 221 NAME is the name of the file (cannot be NULL). COMP_DIR is the 222 directory in which the file was compiled (or NULL if not known). 223 START_ADDR is the lowest address of objects in the file (or 0 if 224 not known). LANGUAGE is the language of the source file, or 225 language_unknown if not known, in which case it'll be deduced from 226 the filename. */ 227 228 struct compunit_symtab * 229 start_compunit_symtab (struct objfile *objfile, const char *name, 230 const char *comp_dir, CORE_ADDR start_addr, 231 enum language language) 232 { 233 /* These should have been reset either by successful completion of building 234 a symtab, or by the scoped_free_pendings destructor. */ 235 gdb_assert (buildsym_compunit == nullptr); 236 237 buildsym_compunit = new struct buildsym_compunit (objfile, name, comp_dir, 238 language, start_addr); 239 240 return buildsym_compunit->get_compunit_symtab (); 241 } 242 243 /* At end of reading syms, or in case of quit, ensure everything 244 associated with building symtabs is freed. 245 246 N.B. This is *not* intended to be used when building psymtabs. Some debug 247 info readers call this anyway, which is harmless if confusing. */ 248 249 scoped_free_pendings::~scoped_free_pendings () 250 { 251 free_buildsym_compunit (); 252 } 253 254 /* See buildsym-legacy.h. */ 255 256 struct buildsym_compunit * 257 get_buildsym_compunit () 258 { 259 gdb_assert (buildsym_compunit != nullptr); 260 return buildsym_compunit; 261 } 262