gdb/buildsym-legacy.c

   1 /* Legacy support routines for building symbol tables in GDB's internal format.
   2    Copyright (C) 1986-2020 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_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 \f
  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 struct using_direct **
  83 get_local_using_directives ()
  84 {
  85   gdb_assert (buildsym_compunit != nullptr);
  86   return buildsym_compunit->get_local_using_directives ();
  87 }
  88
  89 /* See buildsym.h.  */
  90
  91 void
  92 set_local_using_directives (struct using_direct *new_local)
  93 {
  94   gdb_assert (buildsym_compunit != nullptr);
  95   buildsym_compunit->set_local_using_directives (new_local);
  96 }
  97
  98 /* See buildsym.h.  */
  99
 100 struct using_direct **
 101 get_global_using_directives ()
 102 {
 103   gdb_assert (buildsym_compunit != nullptr);
 104   return buildsym_compunit->get_global_using_directives ();
 105 }
 106
 107 /* See buildsym.h.  */
 108
 109 bool
 110 outermost_context_p ()
 111 {
 112   gdb_assert (buildsym_compunit != nullptr);
 113   return buildsym_compunit->outermost_context_p ();
 114 }
 115
 116 /* See buildsym.h.  */
 117
 118 struct context_stack *
 119 get_current_context_stack ()
 120 {
 121   gdb_assert (buildsym_compunit != nullptr);
 122   return buildsym_compunit->get_current_context_stack ();
 123 }
 124
 125 /* See buildsym.h.  */
 126
 127 int
 128 get_context_stack_depth ()
 129 {
 130   gdb_assert (buildsym_compunit != nullptr);
 131   return buildsym_compunit->get_context_stack_depth ();
 132 }
 133
 134 /* See buildsym.h.  */
 135
 136 struct subfile *
 137 get_current_subfile ()
 138 {
 139   gdb_assert (buildsym_compunit != nullptr);
 140   return buildsym_compunit->get_current_subfile ();
 141 }
 142
 143 /* See buildsym.h.  */
 144
 145 struct pending **
 146 get_local_symbols ()
 147 {
 148   gdb_assert (buildsym_compunit != nullptr);
 149   return buildsym_compunit->get_local_symbols ();
 150 }
 151
 152 /* See buildsym.h.  */
 153
 154 struct pending **
 155 get_file_symbols ()
 156 {
 157   gdb_assert (buildsym_compunit != nullptr);
 158   return buildsym_compunit->get_file_symbols ();
 159 }
 160
 161 /* See buildsym.h.  */
 162
 163 struct pending **
 164 get_global_symbols ()
 165 {
 166   gdb_assert (buildsym_compunit != nullptr);
 167   return buildsym_compunit->get_global_symbols ();
 168 }
 169
 170 void
 171 start_subfile (const char *name)
 172 {
 173   gdb_assert (buildsym_compunit != nullptr);
 174   buildsym_compunit->start_subfile (name);
 175 }
 176
 177 void
 178 patch_subfile_names (struct subfile *subfile, const char *name)
 179 {
 180   gdb_assert (buildsym_compunit != nullptr);
 181   buildsym_compunit->patch_subfile_names (subfile, name);
 182 }
 183
 184 void
 185 push_subfile ()
 186 {
 187   gdb_assert (buildsym_compunit != nullptr);
 188   buildsym_compunit->push_subfile ();
 189 }
 190
 191 const char *
 192 pop_subfile ()
 193 {
 194   gdb_assert (buildsym_compunit != nullptr);
 195   return buildsym_compunit->pop_subfile ();
 196 }
 197
 198 /* Delete the buildsym compunit.  */
 199
 200 static void
 201 free_buildsym_compunit (void)
 202 {
 203   if (buildsym_compunit == NULL)
 204     return;
 205   delete buildsym_compunit;
 206   buildsym_compunit = NULL;
 207 }
 208
 209 struct compunit_symtab *
 210 end_symtab (CORE_ADDR end_addr, int section)
 211 {
 212   gdb_assert (buildsym_compunit != nullptr);
 213   struct compunit_symtab *result
 214     = buildsym_compunit->end_symtab (end_addr, section);
 215   free_buildsym_compunit ();
 216   return result;
 217 }
 218
 219 struct context_stack *
 220 push_context (int desc, CORE_ADDR valu)
 221 {
 222   gdb_assert (buildsym_compunit != nullptr);
 223   return buildsym_compunit->push_context (desc, valu);
 224 }
 225
 226 struct context_stack
 227 pop_context ()
 228 {
 229   gdb_assert (buildsym_compunit != nullptr);
 230   return buildsym_compunit->pop_context ();
 231 }
 232
 233 struct block *
 234 finish_block (struct symbol *symbol, struct pending_block *old_blocks,
 235               const struct dynamic_prop *static_link,
 236               CORE_ADDR start, CORE_ADDR end)
 237 {
 238   gdb_assert (buildsym_compunit != nullptr);
 239   return buildsym_compunit->finish_block (symbol, old_blocks, static_link,
 240                                           start, end);
 241 }
 242
 243 void
 244 record_block_range (struct block *block, CORE_ADDR start,
 245                     CORE_ADDR end_inclusive)
 246 {
 247   gdb_assert (buildsym_compunit != nullptr);
 248   buildsym_compunit->record_block_range (block, start, end_inclusive);
 249 }
 250
 251 void
 252 record_line (struct subfile *subfile, int line, CORE_ADDR pc)
 253 {
 254   gdb_assert (buildsym_compunit != nullptr);
 255   /* Assume every line entry is a statement start, that is a good place to
 256      put a breakpoint for that line number.  */
 257   buildsym_compunit->record_line (subfile, line, pc, true);
 258 }
 259
 260 /* Start a new symtab for a new source file in OBJFILE.  Called, for example,
 261    when a stabs symbol of type N_SO is seen, or when a DWARF
 262    TAG_compile_unit DIE is seen.  It indicates the start of data for
 263    one original source file.
 264
 265    NAME is the name of the file (cannot be NULL).  COMP_DIR is the
 266    directory in which the file was compiled (or NULL if not known).
 267    START_ADDR is the lowest address of objects in the file (or 0 if
 268    not known).  LANGUAGE is the language of the source file, or
 269    language_unknown if not known, in which case it'll be deduced from
 270    the filename.  */
 271
 272 struct compunit_symtab *
 273 start_symtab (struct objfile *objfile, const char *name, const char *comp_dir,
 274               CORE_ADDR start_addr, enum language language)
 275 {
 276   /* These should have been reset either by successful completion of building
 277      a symtab, or by the scoped_free_pendings destructor.  */
 278   gdb_assert (buildsym_compunit == nullptr);
 279
 280   buildsym_compunit = new struct buildsym_compunit (objfile, name, comp_dir,
 281                                                     language, start_addr);
 282
 283   return buildsym_compunit->get_compunit_symtab ();
 284 }
 285
 286 /* Restart compilation for a symtab.
 287    CUST is the result of end_expandable_symtab.
 288    NAME, START_ADDR are the source file we are resuming with.
 289
 290    This is used when a symtab is built from multiple sources.
 291    The symtab is first built with start_symtab/end_expandable_symtab
 292    and then for each additional piece call restart_symtab/augment_*_symtab.
 293    Note: At the moment there is only augment_type_symtab.  */
 294
 295 void
 296 restart_symtab (struct compunit_symtab *cust,
 297                 const char *name, CORE_ADDR start_addr)
 298 {
 299   /* These should have been reset either by successful completion of building
 300      a symtab, or by the scoped_free_pendings destructor.  */
 301   gdb_assert (buildsym_compunit == nullptr);
 302
 303   buildsym_compunit
 304     = new struct buildsym_compunit (COMPUNIT_OBJFILE (cust),
 305                                     name,
 306                                     COMPUNIT_DIRNAME (cust),
 307                                     compunit_language (cust),
 308                                     start_addr,
 309                                     cust);
 310 }
 311
 312 /* See buildsym.h.  */
 313
 314 struct compunit_symtab *
 315 buildsym_compunit_symtab (void)
 316 {
 317   gdb_assert (buildsym_compunit != NULL);
 318
 319   return buildsym_compunit->get_compunit_symtab ();
 320 }
 321
 322 /* See buildsym.h.  */
 323
 324 struct macro_table *
 325 get_macro_table (void)
 326 {
 327   gdb_assert (buildsym_compunit != NULL);
 328   return buildsym_compunit->get_macro_table ();
 329 }
 330
 331 /* At end of reading syms, or in case of quit, ensure everything
 332    associated with building symtabs is freed.
 333
 334    N.B. This is *not* intended to be used when building psymtabs.  Some debug
 335    info readers call this anyway, which is harmless if confusing.  */
 336
 337 scoped_free_pendings::~scoped_free_pendings ()
 338 {
 339   free_buildsym_compunit ();
 340 }
 341
 342 /* See buildsym-legacy.h.  */
 343
 344 struct buildsym_compunit *
 345 get_buildsym_compunit ()
 346 {
 347   gdb_assert (buildsym_compunit != nullptr);
 348   return buildsym_compunit;
 349 }