gdb/guile/scm-symtab.c

   1 /* Scheme interface to symbol tables.
   2
   3    Copyright (C) 2008-2022 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 /* See README file in this directory for implementation notes, coding
  21    conventions, et.al.  */
  22
  23 #include "defs.h"
  24 #include "symtab.h"
  25 #include "source.h"
  26 #include "objfiles.h"
  27 #include "block.h"
  28 #include "guile-internal.h"
  29
  30 /* A <gdb:symtab> smob.  */
  31
  32 struct symtab_smob
  33 {
  34   /* This always appears first.
  35      eqable_gdb_smob is used so that symtabs are eq?-able.
  36      Also, a symtab object is associated with an objfile.  eqable_gdb_smob
  37      lets us track the lifetime of all symtabs associated with an objfile.
  38      When an objfile is deleted we need to invalidate the symtab object.  */
  39   eqable_gdb_smob base;
  40
  41   /* The GDB symbol table structure.
  42      If this is NULL the symtab is invalid.  This can happen when the
  43      underlying objfile is freed.  */
  44   struct symtab *symtab;
  45 };
  46
  47 /* A <gdb:sal> smob.
  48    A smob describing a gdb symtab-and-line object.
  49    A sal is associated with an objfile.  All access must be gated by checking
  50    the validity of symtab_scm.
  51    TODO: Sals are not eq?-able at the moment, or even comparable.  */
  52
  53 struct sal_smob
  54 {
  55   /* This always appears first.  */
  56   gdb_smob base;
  57
  58   /* The <gdb:symtab> object of the symtab.
  59      We store this instead of a pointer to the symtab_smob because it's not
  60      clear GC will know the symtab_smob is referenced by us otherwise, and we
  61      need quick access to symtab_smob->symtab to know if this sal is valid.  */
  62   SCM symtab_scm;
  63
  64   /* The GDB symbol table and line structure.
  65      This object is ephemeral in GDB, so keep our own copy.
  66      The symtab pointer in this struct is not usable: If the symtab is deleted
  67      this pointer will not be updated.  Use symtab_scm instead to determine
  68      if this sal is valid.  */
  69   struct symtab_and_line sal;
  70 };
  71
  72 static const char symtab_smob_name[] = "gdb:symtab";
  73 /* "symtab-and-line" is pretty long, and "sal" is short and unique.  */
  74 static const char sal_smob_name[] = "gdb:sal";
  75
  76 /* The tags Guile knows the symbol table smobs by.  */
  77 static scm_t_bits symtab_smob_tag;
  78 static scm_t_bits sal_smob_tag;
  79
  80 static const struct objfile_data *stscm_objfile_data_key;
  81 \f
  82 /* Administrivia for symtab smobs.  */
  83
  84 /* Helper function to hash a symbol_smob.  */
  85
  86 static hashval_t
  87 stscm_hash_symtab_smob (const void *p)
  88 {
  89   const symtab_smob *st_smob = (const symtab_smob *) p;
  90
  91   return htab_hash_pointer (st_smob->symtab);
  92 }
  93
  94 /* Helper function to compute equality of symtab_smobs.  */
  95
  96 static int
  97 stscm_eq_symtab_smob (const void *ap, const void *bp)
  98 {
  99   const symtab_smob *a = (const symtab_smob *) ap;
 100   const symtab_smob *b = (const symtab_smob *) bp;
 101
 102   return (a->symtab == b->symtab
 103           && a->symtab != NULL);
 104 }
 105
 106 /* Return the struct symtab pointer -> SCM mapping table.
 107    It is created if necessary.  */
 108
 109 static htab_t
 110 stscm_objfile_symtab_map (struct symtab *symtab)
 111 {
 112   struct objfile *objfile = symtab->compunit ()->objfile ();
 113   htab_t htab = (htab_t) objfile_data (objfile, stscm_objfile_data_key);
 114
 115   if (htab == NULL)
 116     {
 117       htab = gdbscm_create_eqable_gsmob_ptr_map (stscm_hash_symtab_smob,
 118                                                  stscm_eq_symtab_smob);
 119       set_objfile_data (objfile, stscm_objfile_data_key, htab);
 120     }
 121
 122   return htab;
 123 }
 124
 125 /* The smob "free" function for <gdb:symtab>.  */
 126
 127 static size_t
 128 stscm_free_symtab_smob (SCM self)
 129 {
 130   symtab_smob *st_smob = (symtab_smob *) SCM_SMOB_DATA (self);
 131
 132   if (st_smob->symtab != NULL)
 133     {
 134       htab_t htab = stscm_objfile_symtab_map (st_smob->symtab);
 135
 136       gdbscm_clear_eqable_gsmob_ptr_slot (htab, &st_smob->base);
 137     }
 138
 139   /* Not necessary, done to catch bugs.  */
 140   st_smob->symtab = NULL;
 141
 142   return 0;
 143 }
 144
 145 /* The smob "print" function for <gdb:symtab>.  */
 146
 147 static int
 148 stscm_print_symtab_smob (SCM self, SCM port, scm_print_state *pstate)
 149 {
 150   symtab_smob *st_smob = (symtab_smob *) SCM_SMOB_DATA (self);
 151
 152   gdbscm_printf (port, "#<%s ", symtab_smob_name);
 153   gdbscm_printf (port, "%s",
 154                  st_smob->symtab != NULL
 155                  ? symtab_to_filename_for_display (st_smob->symtab)
 156                  : "<invalid>");
 157   scm_puts (">", port);
 158
 159   scm_remember_upto_here_1 (self);
 160
 161   /* Non-zero means success.  */
 162   return 1;
 163 }
 164
 165 /* Low level routine to create a <gdb:symtab> object.  */
 166
 167 static SCM
 168 stscm_make_symtab_smob (void)
 169 {
 170   symtab_smob *st_smob = (symtab_smob *)
 171     scm_gc_malloc (sizeof (symtab_smob), symtab_smob_name);
 172   SCM st_scm;
 173
 174   st_smob->symtab = NULL;
 175   st_scm = scm_new_smob (symtab_smob_tag, (scm_t_bits) st_smob);
 176   gdbscm_init_eqable_gsmob (&st_smob->base, st_scm);
 177
 178   return st_scm;
 179 }
 180
 181 /* Return non-zero if SCM is a symbol table smob.  */
 182
 183 static int
 184 stscm_is_symtab (SCM scm)
 185 {
 186   return SCM_SMOB_PREDICATE (symtab_smob_tag, scm);
 187 }
 188
 189 /* (symtab? object) -> boolean */
 190
 191 static SCM
 192 gdbscm_symtab_p (SCM scm)
 193 {
 194   return scm_from_bool (stscm_is_symtab (scm));
 195 }
 196
 197 /* Create a new <gdb:symtab> object that encapsulates SYMTAB.  */
 198
 199 SCM
 200 stscm_scm_from_symtab (struct symtab *symtab)
 201 {
 202   htab_t htab;
 203   eqable_gdb_smob **slot;
 204   symtab_smob *st_smob, st_smob_for_lookup;
 205   SCM st_scm;
 206
 207   /* If we've already created a gsmob for this symtab, return it.
 208      This makes symtabs eq?-able.  */
 209   htab = stscm_objfile_symtab_map (symtab);
 210   st_smob_for_lookup.symtab = symtab;
 211   slot = gdbscm_find_eqable_gsmob_ptr_slot (htab, &st_smob_for_lookup.base);
 212   if (*slot != NULL)
 213     return (*slot)->containing_scm;
 214
 215   st_scm = stscm_make_symtab_smob ();
 216   st_smob = (symtab_smob *) SCM_SMOB_DATA (st_scm);
 217   st_smob->symtab = symtab;
 218   gdbscm_fill_eqable_gsmob_ptr_slot (slot, &st_smob->base);
 219
 220   return st_scm;
 221 }
 222
 223 /* Returns the <gdb:symtab> object in SELF.
 224    Throws an exception if SELF is not a <gdb:symtab> object.  */
 225
 226 static SCM
 227 stscm_get_symtab_arg_unsafe (SCM self, int arg_pos, const char *func_name)
 228 {
 229   SCM_ASSERT_TYPE (stscm_is_symtab (self), self, arg_pos, func_name,
 230                    symtab_smob_name);
 231
 232   return self;
 233 }
 234
 235 /* Returns a pointer to the symtab smob of SELF.
 236    Throws an exception if SELF is not a <gdb:symtab> object.  */
 237
 238 static symtab_smob *
 239 stscm_get_symtab_smob_arg_unsafe (SCM self, int arg_pos, const char *func_name)
 240 {
 241   SCM st_scm = stscm_get_symtab_arg_unsafe (self, arg_pos, func_name);
 242   symtab_smob *st_smob = (symtab_smob *) SCM_SMOB_DATA (st_scm);
 243
 244   return st_smob;
 245 }
 246
 247 /* Return non-zero if symtab ST_SMOB is valid.  */
 248
 249 static int
 250 stscm_is_valid (symtab_smob *st_smob)
 251 {
 252   return st_smob->symtab != NULL;
 253 }
 254
 255 /* Throw a Scheme error if SELF is not a valid symtab smob.
 256    Otherwise return a pointer to the symtab_smob object.  */
 257
 258 static symtab_smob *
 259 stscm_get_valid_symtab_smob_arg_unsafe (SCM self, int arg_pos,
 260                                         const char *func_name)
 261 {
 262   symtab_smob *st_smob
 263     = stscm_get_symtab_smob_arg_unsafe (self, arg_pos, func_name);
 264
 265   if (!stscm_is_valid (st_smob))
 266     {
 267       gdbscm_invalid_object_error (func_name, arg_pos, self,
 268                                    _("<gdb:symtab>"));
 269     }
 270
 271   return st_smob;
 272 }
 273
 274 /* Helper function for stscm_del_objfile_symtabs to mark the symtab
 275    as invalid.  */
 276
 277 static int
 278 stscm_mark_symtab_invalid (void **slot, void *info)
 279 {
 280   symtab_smob *st_smob = (symtab_smob *) *slot;
 281
 282   st_smob->symtab = NULL;
 283   return 1;
 284 }
 285
 286 /* This function is called when an objfile is about to be freed.
 287    Invalidate the symbol table as further actions on the symbol table
 288    would result in bad data.  All access to st_smob->symtab should be
 289    gated by stscm_get_valid_symtab_smob_arg_unsafe which will raise an
 290    exception on invalid symbol tables.  */
 291
 292 static void
 293 stscm_del_objfile_symtabs (struct objfile *objfile, void *datum)
 294 {
 295   htab_t htab = (htab_t) datum;
 296
 297   if (htab != NULL)
 298     {
 299       htab_traverse_noresize (htab, stscm_mark_symtab_invalid, NULL);
 300       htab_delete (htab);
 301     }
 302 }
 303 \f
 304 /* Symbol table methods.  */
 305
 306 /* (symtab-valid? <gdb:symtab>) -> boolean
 307    Returns #t if SELF still exists in GDB.  */
 308
 309 static SCM
 310 gdbscm_symtab_valid_p (SCM self)
 311 {
 312   symtab_smob *st_smob
 313     = stscm_get_symtab_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 314
 315   return scm_from_bool (stscm_is_valid (st_smob));
 316 }
 317
 318 /* (symtab-filename <gdb:symtab>) -> string */
 319
 320 static SCM
 321 gdbscm_symtab_filename (SCM self)
 322 {
 323   symtab_smob *st_smob
 324     = stscm_get_valid_symtab_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 325   struct symtab *symtab = st_smob->symtab;
 326
 327   return gdbscm_scm_from_c_string (symtab_to_filename_for_display (symtab));
 328 }
 329
 330 /* (symtab-fullname <gdb:symtab>) -> string */
 331
 332 static SCM
 333 gdbscm_symtab_fullname (SCM self)
 334 {
 335   symtab_smob *st_smob
 336     = stscm_get_valid_symtab_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 337   struct symtab *symtab = st_smob->symtab;
 338
 339   return gdbscm_scm_from_c_string (symtab_to_fullname (symtab));
 340 }
 341
 342 /* (symtab-objfile <gdb:symtab>) -> <gdb:objfile> */
 343
 344 static SCM
 345 gdbscm_symtab_objfile (SCM self)
 346 {
 347   symtab_smob *st_smob
 348     = stscm_get_valid_symtab_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 349   const struct symtab *symtab = st_smob->symtab;
 350
 351   return ofscm_scm_from_objfile (symtab->compunit ()->objfile ());
 352 }
 353
 354 /* (symtab-global-block <gdb:symtab>) -> <gdb:block>
 355    Return the GLOBAL_BLOCK of the underlying symtab.  */
 356
 357 static SCM
 358 gdbscm_symtab_global_block (SCM self)
 359 {
 360   symtab_smob *st_smob
 361     = stscm_get_valid_symtab_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 362   const struct symtab *symtab = st_smob->symtab;
 363   const struct blockvector *blockvector;
 364
 365   blockvector = symtab->compunit ()->blockvector ();
 366   const struct block *block = blockvector->global_block ();
 367
 368   return bkscm_scm_from_block (block, symtab->compunit ()->objfile ());
 369 }
 370
 371 /* (symtab-static-block <gdb:symtab>) -> <gdb:block>
 372    Return the STATIC_BLOCK of the underlying symtab.  */
 373
 374 static SCM
 375 gdbscm_symtab_static_block (SCM self)
 376 {
 377   symtab_smob *st_smob
 378     = stscm_get_valid_symtab_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 379   const struct symtab *symtab = st_smob->symtab;
 380   const struct blockvector *blockvector;
 381
 382   blockvector = symtab->compunit ()->blockvector ();
 383   const struct block *block = blockvector->static_block ();
 384
 385   return bkscm_scm_from_block (block, symtab->compunit ()->objfile ());
 386 }
 387 \f
 388 /* Administrivia for sal (symtab-and-line) smobs.  */
 389
 390 /* The smob "print" function for <gdb:sal>.  */
 391
 392 static int
 393 stscm_print_sal_smob (SCM self, SCM port, scm_print_state *pstate)
 394 {
 395   sal_smob *s_smob = (sal_smob *) SCM_SMOB_DATA (self);
 396
 397   gdbscm_printf (port, "#<%s ", symtab_smob_name);
 398   scm_write (s_smob->symtab_scm, port);
 399   if (s_smob->sal.line != 0)
 400     gdbscm_printf (port, " line %d", s_smob->sal.line);
 401   scm_puts (">", port);
 402
 403   scm_remember_upto_here_1 (self);
 404
 405   /* Non-zero means success.  */
 406   return 1;
 407 }
 408
 409 /* Low level routine to create a <gdb:sal> object.  */
 410
 411 static SCM
 412 stscm_make_sal_smob (void)
 413 {
 414   sal_smob *s_smob
 415     = (sal_smob *) scm_gc_malloc (sizeof (sal_smob), sal_smob_name);
 416   SCM s_scm;
 417
 418   s_smob->symtab_scm = SCM_BOOL_F;
 419   new (&s_smob->sal) symtab_and_line ();
 420   s_scm = scm_new_smob (sal_smob_tag, (scm_t_bits) s_smob);
 421   gdbscm_init_gsmob (&s_smob->base);
 422
 423   return s_scm;
 424 }
 425
 426 /* Return non-zero if SCM is a <gdb:sal> object.  */
 427
 428 static int
 429 stscm_is_sal (SCM scm)
 430 {
 431   return SCM_SMOB_PREDICATE (sal_smob_tag, scm);
 432 }
 433
 434 /* (sal? object) -> boolean */
 435
 436 static SCM
 437 gdbscm_sal_p (SCM scm)
 438 {
 439   return scm_from_bool (stscm_is_sal (scm));
 440 }
 441
 442 /* Create a new <gdb:sal> object that encapsulates SAL.  */
 443
 444 SCM
 445 stscm_scm_from_sal (struct symtab_and_line sal)
 446 {
 447   SCM st_scm, s_scm;
 448   sal_smob *s_smob;
 449
 450   st_scm = SCM_BOOL_F;
 451   if (sal.symtab != NULL)
 452     st_scm = stscm_scm_from_symtab (sal.symtab);
 453
 454   s_scm = stscm_make_sal_smob ();
 455   s_smob = (sal_smob *) SCM_SMOB_DATA (s_scm);
 456   s_smob->symtab_scm = st_scm;
 457   s_smob->sal = sal;
 458
 459   return s_scm;
 460 }
 461
 462 /* Returns the <gdb:sal> object in SELF.
 463    Throws an exception if SELF is not a <gdb:sal> object.  */
 464
 465 static SCM
 466 stscm_get_sal_arg (SCM self, int arg_pos, const char *func_name)
 467 {
 468   SCM_ASSERT_TYPE (stscm_is_sal (self), self, arg_pos, func_name,
 469                    sal_smob_name);
 470
 471   return self;
 472 }
 473
 474 /* Returns a pointer to the sal smob of SELF.
 475    Throws an exception if SELF is not a <gdb:sal> object.  */
 476
 477 static sal_smob *
 478 stscm_get_sal_smob_arg (SCM self, int arg_pos, const char *func_name)
 479 {
 480   SCM s_scm = stscm_get_sal_arg (self, arg_pos, func_name);
 481   sal_smob *s_smob = (sal_smob *) SCM_SMOB_DATA (s_scm);
 482
 483   return s_smob;
 484 }
 485
 486 /* Return non-zero if the symtab in S_SMOB is valid.  */
 487
 488 static int
 489 stscm_sal_is_valid (sal_smob *s_smob)
 490 {
 491   symtab_smob *st_smob;
 492
 493   /* If there's no symtab that's ok, the sal is still valid.  */
 494   if (gdbscm_is_false (s_smob->symtab_scm))
 495     return 1;
 496
 497   st_smob = (symtab_smob *) SCM_SMOB_DATA (s_smob->symtab_scm);
 498
 499   return st_smob->symtab != NULL;
 500 }
 501
 502 /* Throw a Scheme error if SELF is not a valid sal smob.
 503    Otherwise return a pointer to the sal_smob object.  */
 504
 505 static sal_smob *
 506 stscm_get_valid_sal_smob_arg (SCM self, int arg_pos, const char *func_name)
 507 {
 508   sal_smob *s_smob = stscm_get_sal_smob_arg (self, arg_pos, func_name);
 509
 510   if (!stscm_sal_is_valid (s_smob))
 511     {
 512       gdbscm_invalid_object_error (func_name, arg_pos, self,
 513                                    _("<gdb:sal>"));
 514     }
 515
 516   return s_smob;
 517 }
 518 \f
 519 /* sal methods */
 520
 521 /* (sal-valid? <gdb:sal>) -> boolean
 522    Returns #t if the symtab for SELF still exists in GDB.  */
 523
 524 static SCM
 525 gdbscm_sal_valid_p (SCM self)
 526 {
 527   sal_smob *s_smob = stscm_get_sal_smob_arg (self, SCM_ARG1, FUNC_NAME);
 528
 529   return scm_from_bool (stscm_sal_is_valid (s_smob));
 530 }
 531
 532 /* (sal-pc <gdb:sal>) -> address */
 533
 534 static SCM
 535 gdbscm_sal_pc (SCM self)
 536 {
 537   sal_smob *s_smob = stscm_get_valid_sal_smob_arg (self, SCM_ARG1, FUNC_NAME);
 538   const struct symtab_and_line *sal = &s_smob->sal;
 539
 540   return gdbscm_scm_from_ulongest (sal->pc);
 541 }
 542
 543 /* (sal-last <gdb:sal>) -> address
 544    Returns #f if no ending address is recorded.  */
 545
 546 static SCM
 547 gdbscm_sal_last (SCM self)
 548 {
 549   sal_smob *s_smob = stscm_get_valid_sal_smob_arg (self, SCM_ARG1, FUNC_NAME);
 550   const struct symtab_and_line *sal = &s_smob->sal;
 551
 552   if (sal->end > 0)
 553     return gdbscm_scm_from_ulongest (sal->end - 1);
 554   return SCM_BOOL_F;
 555 }
 556
 557 /* (sal-line <gdb:sal>) -> integer
 558    Returns #f if no line number is recorded.  */
 559
 560 static SCM
 561 gdbscm_sal_line (SCM self)
 562 {
 563   sal_smob *s_smob = stscm_get_valid_sal_smob_arg (self, SCM_ARG1, FUNC_NAME);
 564   const struct symtab_and_line *sal = &s_smob->sal;
 565
 566   if (sal->line > 0)
 567     return scm_from_int (sal->line);
 568   return SCM_BOOL_F;
 569 }
 570
 571 /* (sal-symtab <gdb:sal>) -> <gdb:symtab>
 572    Returns #f if no symtab is recorded.  */
 573
 574 static SCM
 575 gdbscm_sal_symtab (SCM self)
 576 {
 577   sal_smob *s_smob = stscm_get_valid_sal_smob_arg (self, SCM_ARG1, FUNC_NAME);
 578
 579   return s_smob->symtab_scm;
 580 }
 581
 582 /* (find-pc-line address) -> <gdb:sal> */
 583
 584 static SCM
 585 gdbscm_find_pc_line (SCM pc_scm)
 586 {
 587   ULONGEST pc_ull;
 588   symtab_and_line sal;
 589
 590   gdbscm_parse_function_args (FUNC_NAME, SCM_ARG1, NULL, "U", pc_scm, &pc_ull);
 591
 592   gdbscm_gdb_exception exc {};
 593   try
 594     {
 595       CORE_ADDR pc = (CORE_ADDR) pc_ull;
 596
 597       sal = find_pc_line (pc, 0);
 598     }
 599   catch (const gdb_exception &except)
 600     {
 601       exc = unpack (except);
 602     }
 603
 604   GDBSCM_HANDLE_GDB_EXCEPTION (exc);
 605   return stscm_scm_from_sal (sal);
 606 }
 607 \f
 608 /* Initialize the Scheme symbol support.  */
 609
 610 static const scheme_function symtab_functions[] =
 611 {
 612   { "symtab?", 1, 0, 0, as_a_scm_t_subr (gdbscm_symtab_p),
 613     "\
 614 Return #t if the object is a <gdb:symtab> object." },
 615
 616   { "symtab-valid?", 1, 0, 0, as_a_scm_t_subr (gdbscm_symtab_valid_p),
 617     "\
 618 Return #t if the symtab still exists in GDB.\n\
 619 Symtabs are deleted when the corresponding objfile is freed." },
 620
 621   { "symtab-filename", 1, 0, 0, as_a_scm_t_subr (gdbscm_symtab_filename),
 622     "\
 623 Return the symtab's source file name." },
 624
 625   { "symtab-fullname", 1, 0, 0, as_a_scm_t_subr (gdbscm_symtab_fullname),
 626     "\
 627 Return the symtab's full source file name." },
 628
 629   { "symtab-objfile", 1, 0, 0, as_a_scm_t_subr (gdbscm_symtab_objfile),
 630     "\
 631 Return the symtab's objfile." },
 632
 633   { "symtab-global-block", 1, 0, 0,
 634     as_a_scm_t_subr (gdbscm_symtab_global_block),
 635     "\
 636 Return the symtab's global block." },
 637
 638   { "symtab-static-block", 1, 0, 0,
 639     as_a_scm_t_subr (gdbscm_symtab_static_block),
 640     "\
 641 Return the symtab's static block." },
 642
 643   { "sal?", 1, 0, 0, as_a_scm_t_subr (gdbscm_sal_p),
 644     "\
 645 Return #t if the object is a <gdb:sal> (symtab-and-line) object." },
 646
 647   { "sal-valid?", 1, 0, 0, as_a_scm_t_subr (gdbscm_sal_valid_p),
 648     "\
 649 Return #t if the symtab for the sal still exists in GDB.\n\
 650 Symtabs are deleted when the corresponding objfile is freed." },
 651
 652   { "sal-symtab", 1, 0, 0, as_a_scm_t_subr (gdbscm_sal_symtab),
 653     "\
 654 Return the sal's symtab." },
 655
 656   { "sal-line", 1, 0, 0, as_a_scm_t_subr (gdbscm_sal_line),
 657     "\
 658 Return the sal's line number, or #f if there is none." },
 659
 660   { "sal-pc", 1, 0, 0, as_a_scm_t_subr (gdbscm_sal_pc),
 661     "\
 662 Return the sal's address." },
 663
 664   { "sal-last", 1, 0, 0, as_a_scm_t_subr (gdbscm_sal_last),
 665     "\
 666 Return the last address specified by the sal, or #f if there is none." },
 667
 668   { "find-pc-line", 1, 0, 0, as_a_scm_t_subr (gdbscm_find_pc_line),
 669     "\
 670 Return the sal corresponding to the address, or #f if there isn't one.\n\
 671 \n\
 672   Arguments: address" },
 673
 674   END_FUNCTIONS
 675 };
 676
 677 void
 678 gdbscm_initialize_symtabs (void)
 679 {
 680   symtab_smob_tag
 681     = gdbscm_make_smob_type (symtab_smob_name, sizeof (symtab_smob));
 682   scm_set_smob_free (symtab_smob_tag, stscm_free_symtab_smob);
 683   scm_set_smob_print (symtab_smob_tag, stscm_print_symtab_smob);
 684
 685   sal_smob_tag = gdbscm_make_smob_type (sal_smob_name, sizeof (sal_smob));
 686   scm_set_smob_print (sal_smob_tag, stscm_print_sal_smob);
 687
 688   gdbscm_define_functions (symtab_functions, 1);
 689 }
 690
 691 void _initialize_scm_symtab ();
 692 void
 693 _initialize_scm_symtab ()
 694 {
 695   /* Register an objfile "free" callback so we can properly
 696      invalidate symbol tables, and symbol table and line data
 697      structures when an object file that is about to be deleted.  */
 698   stscm_objfile_data_key
 699     = register_objfile_data_with_cleanup (NULL, stscm_del_objfile_symtabs);
 700 }