gdb/block.c

   1 /* Block-related functions for the GNU debugger, GDB.
   2
   3    Copyright (C) 2003-2024 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 #include "defs.h"
  21 #include "block.h"
  22 #include "symtab.h"
  23 #include "symfile.h"
  24 #include "gdbsupport/gdb_obstack.h"
  25 #include "cp-support.h"
  26 #include "addrmap.h"
  27 #include "gdbtypes.h"
  28 #include "objfiles.h"
  29
  30 /* This is used by struct block to store namespace-related info for
  31    C++ files, namely using declarations and the current namespace in
  32    scope.  */
  33
  34 struct block_namespace_info : public allocate_on_obstack
  35 {
  36   const char *scope = nullptr;
  37   struct using_direct *using_decl = nullptr;
  38 };
  39
  40 /* See block.h.  */
  41
  42 struct objfile *
  43 block::objfile () const
  44 {
  45   const struct global_block *global_block;
  46
  47   if (function () != nullptr)
  48     return function ()->objfile ();
  49
  50   global_block = (struct global_block *) this->global_block ();
  51   return global_block->compunit_symtab->objfile ();
  52 }
  53
  54 /* See block.  */
  55
  56 struct gdbarch *
  57 block::gdbarch () const
  58 {
  59   if (function () != nullptr)
  60     return function ()->arch ();
  61
  62   return objfile ()->arch ();
  63 }
  64
  65 /* See block.h.  */
  66
  67 bool
  68 block::contains (const struct block *a, bool allow_nested) const
  69 {
  70   if (a == nullptr)
  71     return false;
  72
  73   do
  74     {
  75       if (a == this)
  76         return true;
  77       /* If A is a function block, then A cannot be contained in B,
  78          except if A was inlined.  */
  79       if (!allow_nested && a->function () != NULL && !a->inlined_p ())
  80         return false;
  81       a = a->superblock ();
  82     }
  83   while (a != NULL);
  84
  85   return false;
  86 }
  87
  88 /* See block.h.  */
  89
  90 struct symbol *
  91 block::linkage_function () const
  92 {
  93   const block *bl = this;
  94
  95   while ((bl->function () == NULL || bl->inlined_p ())
  96          && bl->superblock () != NULL)
  97     bl = bl->superblock ();
  98
  99   return bl->function ();
 100 }
 101
 102 /* See block.h.  */
 103
 104 struct symbol *
 105 block::containing_function () const
 106 {
 107   const block *bl = this;
 108
 109   while (bl->function () == NULL && bl->superblock () != NULL)
 110     bl = bl->superblock ();
 111
 112   return bl->function ();
 113 }
 114
 115 /* See block.h.  */
 116
 117 bool
 118 block::inlined_p () const
 119 {
 120   return function () != nullptr && function ()->is_inlined ();
 121 }
 122
 123 /* A helper function that checks whether PC is in the blockvector BL.
 124    It returns the containing block if there is one, or else NULL.  */
 125
 126 static const struct block *
 127 find_block_in_blockvector (const struct blockvector *bl, CORE_ADDR pc)
 128 {
 129   const struct block *b;
 130   int bot, top, half;
 131
 132   /* If we have an addrmap mapping code addresses to blocks, then use
 133      that.  */
 134   if (bl->map ())
 135     return (const struct block *) bl->map ()->find (pc);
 136
 137   /* Otherwise, use binary search to find the last block that starts
 138      before PC.
 139      Note: GLOBAL_BLOCK is block 0, STATIC_BLOCK is block 1.
 140      They both have the same START,END values.
 141      Historically this code would choose STATIC_BLOCK over GLOBAL_BLOCK but the
 142      fact that this choice was made was subtle, now we make it explicit.  */
 143   gdb_assert (bl->blocks ().size () >= 2);
 144   bot = STATIC_BLOCK;
 145   top = bl->blocks ().size ();
 146
 147   while (top - bot > 1)
 148     {
 149       half = (top - bot + 1) >> 1;
 150       b = bl->block (bot + half);
 151       if (b->start () <= pc)
 152         bot += half;
 153       else
 154         top = bot + half;
 155     }
 156
 157   /* Now search backward for a block that ends after PC.  */
 158
 159   while (bot >= STATIC_BLOCK)
 160     {
 161       b = bl->block (bot);
 162       if (!(b->start () <= pc))
 163         return NULL;
 164       if (b->end () > pc)
 165         return b;
 166       bot--;
 167     }
 168
 169   return NULL;
 170 }
 171
 172 /* Return the blockvector immediately containing the innermost lexical
 173    block containing the specified pc value and section, or 0 if there
 174    is none.  PBLOCK is a pointer to the block.  If PBLOCK is NULL, we
 175    don't pass this information back to the caller.  */
 176
 177 const struct blockvector *
 178 blockvector_for_pc_sect (CORE_ADDR pc, struct obj_section *section,
 179                          const struct block **pblock,
 180                          struct compunit_symtab *cust)
 181 {
 182   const struct blockvector *bl;
 183   const struct block *b;
 184
 185   if (cust == NULL)
 186     {
 187       /* First search all symtabs for one whose file contains our pc */
 188       cust = find_pc_sect_compunit_symtab (pc, section);
 189       if (cust == NULL)
 190         return 0;
 191     }
 192
 193   bl = cust->blockvector ();
 194
 195   /* Then search that symtab for the smallest block that wins.  */
 196   b = find_block_in_blockvector (bl, pc);
 197   if (b == NULL)
 198     return NULL;
 199
 200   if (pblock)
 201     *pblock = b;
 202   return bl;
 203 }
 204
 205 /* Return true if the blockvector BV contains PC, false otherwise.  */
 206
 207 int
 208 blockvector_contains_pc (const struct blockvector *bv, CORE_ADDR pc)
 209 {
 210   return find_block_in_blockvector (bv, pc) != NULL;
 211 }
 212
 213 /* Return call_site for specified PC in GDBARCH.  PC must match exactly, it
 214    must be the next instruction after call (or after tail call jump).  Throw
 215    NO_ENTRY_VALUE_ERROR otherwise.  This function never returns NULL.  */
 216
 217 struct call_site *
 218 call_site_for_pc (struct gdbarch *gdbarch, CORE_ADDR pc)
 219 {
 220   struct compunit_symtab *cust;
 221   call_site *cs = nullptr;
 222
 223   /* -1 as tail call PC can be already after the compilation unit range.  */
 224   cust = find_pc_compunit_symtab (pc - 1);
 225
 226   if (cust != nullptr)
 227     cs = cust->find_call_site (pc);
 228
 229   if (cs == nullptr)
 230     {
 231       struct bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (pc);
 232
 233       /* DW_TAG_gnu_call_site will be missing just if GCC could not determine
 234          the call target.  */
 235       throw_error (NO_ENTRY_VALUE_ERROR,
 236                    _("DW_OP_entry_value resolving cannot find "
 237                      "DW_TAG_call_site %s in %s"),
 238                    paddress (gdbarch, pc),
 239                    (msym.minsym == NULL ? "???"
 240                     : msym.minsym->print_name ()));
 241     }
 242
 243   return cs;
 244 }
 245
 246 /* Return the blockvector immediately containing the innermost lexical block
 247    containing the specified pc value, or 0 if there is none.
 248    Backward compatibility, no section.  */
 249
 250 const struct blockvector *
 251 blockvector_for_pc (CORE_ADDR pc, const struct block **pblock)
 252 {
 253   return blockvector_for_pc_sect (pc, find_pc_mapped_section (pc),
 254                                   pblock, NULL);
 255 }
 256
 257 /* Return the innermost lexical block containing the specified pc value
 258    in the specified section, or 0 if there is none.  */
 259
 260 const struct block *
 261 block_for_pc_sect (CORE_ADDR pc, struct obj_section *section)
 262 {
 263   const struct blockvector *bl;
 264   const struct block *b;
 265
 266   bl = blockvector_for_pc_sect (pc, section, &b, NULL);
 267   if (bl)
 268     return b;
 269   return 0;
 270 }
 271
 272 /* Return the innermost lexical block containing the specified pc value,
 273    or 0 if there is none.  Backward compatibility, no section.  */
 274
 275 const struct block *
 276 block_for_pc (CORE_ADDR pc)
 277 {
 278   return block_for_pc_sect (pc, find_pc_mapped_section (pc));
 279 }
 280
 281 /* Now come some functions designed to deal with C++ namespace issues.
 282    The accessors are safe to use even in the non-C++ case.  */
 283
 284 /* See block.h.  */
 285
 286 const char *
 287 block::scope () const
 288 {
 289   for (const block *block = this;
 290        block != nullptr;
 291        block = block->superblock ())
 292     {
 293       if (block->m_namespace_info != nullptr
 294           && block->m_namespace_info->scope != nullptr)
 295         return block->m_namespace_info->scope;
 296     }
 297
 298   return "";
 299 }
 300
 301 /* See block.h.  */
 302
 303 void
 304 block::initialize_namespace (struct obstack *obstack)
 305 {
 306   if (m_namespace_info == nullptr)
 307     m_namespace_info = new (obstack) struct block_namespace_info;
 308 }
 309
 310 /* See block.h.  */
 311
 312 void
 313 block::set_scope (const char *scope, struct obstack *obstack)
 314 {
 315   if (scope == nullptr || scope[0] == '\0')
 316     {
 317       /* Don't bother.  */
 318       return;
 319     }
 320
 321   initialize_namespace (obstack);
 322   m_namespace_info->scope = scope;
 323 }
 324
 325 /* See block.h.  */
 326
 327 struct using_direct *
 328 block::get_using () const
 329 {
 330   if (m_namespace_info == nullptr)
 331     return nullptr;
 332   else
 333     return m_namespace_info->using_decl;
 334 }
 335
 336 /* See block.h.  */
 337
 338 void
 339 block::set_using (struct using_direct *using_decl, struct obstack *obstack)
 340 {
 341   if (using_decl == nullptr)
 342     {
 343       /* Don't bother.  */
 344       return;
 345     }
 346
 347   initialize_namespace (obstack);
 348   m_namespace_info->using_decl = using_decl;
 349 }
 350
 351 /* See block.h.  */
 352
 353 const struct block *
 354 block::static_block () const
 355 {
 356   if (superblock () == nullptr)
 357     return nullptr;
 358
 359   const block *block = this;
 360   while (block->superblock ()->superblock () != NULL)
 361     block = block->superblock ();
 362
 363   return block;
 364 }
 365
 366 /* See block.h.  */
 367
 368 const struct block *
 369 block::global_block () const
 370 {
 371   const block *block = this;
 372
 373   while (block->superblock () != NULL)
 374     block = block->superblock ();
 375
 376   return block;
 377 }
 378
 379 /* See block.h.  */
 380
 381 const struct block *
 382 block::function_block () const
 383 {
 384   const block *block = this;
 385
 386   while (block != nullptr && block->function () == nullptr)
 387     block = block->superblock ();
 388
 389   return block;
 390 }
 391
 392 /* See block.h.  */
 393
 394 void
 395 block::set_compunit_symtab (struct compunit_symtab *cu)
 396 {
 397   struct global_block *gb;
 398
 399   gdb_assert (superblock () == NULL);
 400   gb = (struct global_block *) this;
 401   gdb_assert (gb->compunit_symtab == NULL);
 402   gb->compunit_symtab = cu;
 403 }
 404
 405 /* See block.h.  */
 406
 407 struct dynamic_prop *
 408 block::static_link () const
 409 {
 410   struct objfile *objfile = this->objfile ();
 411
 412   /* Only objfile-owned blocks that materialize top function scopes can have
 413      static links.  */
 414   if (objfile == NULL || function () == NULL)
 415     return NULL;
 416
 417   return (struct dynamic_prop *) objfile_lookup_static_link (objfile, this);
 418 }
 419
 420 /* Return the compunit of the global block.  */
 421
 422 static struct compunit_symtab *
 423 get_block_compunit_symtab (const struct block *block)
 424 {
 425   struct global_block *gb;
 426
 427   gdb_assert (block->superblock () == NULL);
 428   gb = (struct global_block *) block;
 429   gdb_assert (gb->compunit_symtab != NULL);
 430   return gb->compunit_symtab;
 431 }
 432
 433 \f
 434
 435 /* Initialize a block iterator, either to iterate over a single block,
 436    or, for static and global blocks, all the included symtabs as
 437    well.  */
 438
 439 static void
 440 initialize_block_iterator (const struct block *block,
 441                            struct block_iterator *iter,
 442                            const lookup_name_info *name = nullptr)
 443 {
 444   enum block_enum which;
 445   struct compunit_symtab *cu;
 446
 447   iter->idx = -1;
 448   iter->name = name;
 449
 450   if (block->superblock () == NULL)
 451     {
 452       which = GLOBAL_BLOCK;
 453       cu = get_block_compunit_symtab (block);
 454     }
 455   else if (block->superblock ()->superblock () == NULL)
 456     {
 457       which = STATIC_BLOCK;
 458       cu = get_block_compunit_symtab (block->superblock ());
 459     }
 460   else
 461     {
 462       iter->d.block = block;
 463       /* A signal value meaning that we're iterating over a single
 464          block.  */
 465       iter->which = FIRST_LOCAL_BLOCK;
 466       return;
 467     }
 468
 469   /* If this is an included symtab, find the canonical includer and
 470      use it instead.  */
 471   while (cu->user != NULL)
 472     cu = cu->user;
 473
 474   /* Putting this check here simplifies the logic of the iterator
 475      functions.  If there are no included symtabs, we only need to
 476      search a single block, so we might as well just do that
 477      directly.  */
 478   if (cu->includes == NULL)
 479     {
 480       iter->d.block = block;
 481       /* A signal value meaning that we're iterating over a single
 482          block.  */
 483       iter->which = FIRST_LOCAL_BLOCK;
 484     }
 485   else
 486     {
 487       iter->d.compunit_symtab = cu;
 488       iter->which = which;
 489     }
 490 }
 491
 492 /* A helper function that finds the current compunit over whose static
 493    or global block we should iterate.  */
 494
 495 static struct compunit_symtab *
 496 find_iterator_compunit_symtab (struct block_iterator *iterator)
 497 {
 498   if (iterator->idx == -1)
 499     return iterator->d.compunit_symtab;
 500   return iterator->d.compunit_symtab->includes[iterator->idx];
 501 }
 502
 503 /* Perform a single step for a plain block iterator, iterating across
 504    symbol tables as needed.  Returns the next symbol, or NULL when
 505    iteration is complete.  */
 506
 507 static struct symbol *
 508 block_iterator_step (struct block_iterator *iterator, int first)
 509 {
 510   struct symbol *sym;
 511
 512   gdb_assert (iterator->which != FIRST_LOCAL_BLOCK);
 513
 514   while (1)
 515     {
 516       if (first)
 517         {
 518           struct compunit_symtab *cust
 519             = find_iterator_compunit_symtab (iterator);
 520           const struct block *block;
 521
 522           /* Iteration is complete.  */
 523           if (cust == NULL)
 524             return  NULL;
 525
 526           block = cust->blockvector ()->block (iterator->which);
 527           sym = mdict_iterator_first (block->multidict (),
 528                                       &iterator->mdict_iter);
 529         }
 530       else
 531         sym = mdict_iterator_next (&iterator->mdict_iter);
 532
 533       if (sym != NULL)
 534         return sym;
 535
 536       /* We have finished iterating the appropriate block of one
 537          symtab.  Now advance to the next symtab and begin iteration
 538          there.  */
 539       ++iterator->idx;
 540       first = 1;
 541     }
 542 }
 543
 544 /* Perform a single step for a "match" block iterator, iterating
 545    across symbol tables as needed.  Returns the next symbol, or NULL
 546    when iteration is complete.  */
 547
 548 static struct symbol *
 549 block_iter_match_step (struct block_iterator *iterator,
 550                        int first)
 551 {
 552   struct symbol *sym;
 553
 554   gdb_assert (iterator->which != FIRST_LOCAL_BLOCK);
 555
 556   while (1)
 557     {
 558       if (first)
 559         {
 560           struct compunit_symtab *cust
 561             = find_iterator_compunit_symtab (iterator);
 562           const struct block *block;
 563
 564           /* Iteration is complete.  */
 565           if (cust == NULL)
 566             return  NULL;
 567
 568           block = cust->blockvector ()->block (iterator->which);
 569           sym = mdict_iter_match_first (block->multidict (), *iterator->name,
 570                                         &iterator->mdict_iter);
 571         }
 572       else
 573         sym = mdict_iter_match_next (*iterator->name, &iterator->mdict_iter);
 574
 575       if (sym != NULL)
 576         return sym;
 577
 578       /* We have finished iterating the appropriate block of one
 579          symtab.  Now advance to the next symtab and begin iteration
 580          there.  */
 581       ++iterator->idx;
 582       first = 1;
 583     }
 584 }
 585
 586 /* See block.h.  */
 587
 588 struct symbol *
 589 block_iterator_first (const struct block *block,
 590                       struct block_iterator *iterator,
 591                       const lookup_name_info *name)
 592 {
 593   initialize_block_iterator (block, iterator, name);
 594
 595   if (name == nullptr)
 596     {
 597       if (iterator->which == FIRST_LOCAL_BLOCK)
 598         return mdict_iterator_first (block->multidict (),
 599                                      &iterator->mdict_iter);
 600
 601       return block_iterator_step (iterator, 1);
 602     }
 603
 604   if (iterator->which == FIRST_LOCAL_BLOCK)
 605     return mdict_iter_match_first (block->multidict (), *name,
 606                                    &iterator->mdict_iter);
 607
 608   return block_iter_match_step (iterator, 1);
 609 }
 610
 611 /* See block.h.  */
 612
 613 struct symbol *
 614 block_iterator_next (struct block_iterator *iterator)
 615 {
 616   if (iterator->name == nullptr)
 617     {
 618       if (iterator->which == FIRST_LOCAL_BLOCK)
 619         return mdict_iterator_next (&iterator->mdict_iter);
 620
 621       return block_iterator_step (iterator, 0);
 622     }
 623
 624   if (iterator->which == FIRST_LOCAL_BLOCK)
 625     return mdict_iter_match_next (*iterator->name, &iterator->mdict_iter);
 626
 627   return block_iter_match_step (iterator, 0);
 628 }
 629
 630 /* See block.h.  */
 631
 632 bool
 633 best_symbol (struct symbol *a, const domain_search_flags domain)
 634 {
 635   if (a->aclass () == LOC_UNRESOLVED)
 636     return false;
 637
 638   if ((domain & SEARCH_VAR_DOMAIN) != 0)
 639     return a->domain () == VAR_DOMAIN;
 640
 641   return a->matches (domain);
 642 }
 643
 644 /* See block.h.  */
 645
 646 struct symbol *
 647 better_symbol (struct symbol *a, struct symbol *b,
 648                const domain_search_flags domain)
 649 {
 650   if (a == NULL)
 651     return b;
 652   if (b == NULL)
 653     return a;
 654
 655   if (a->matches (domain) && !b->matches (domain))
 656     return a;
 657
 658   if (b->matches (domain) && !a->matches (domain))
 659     return b;
 660
 661   if (a->aclass () != LOC_UNRESOLVED && b->aclass () == LOC_UNRESOLVED)
 662     return a;
 663
 664   if (b->aclass () != LOC_UNRESOLVED && a->aclass () == LOC_UNRESOLVED)
 665     return b;
 666
 667   return a;
 668 }
 669
 670 /* See block.h.
 671
 672    Note that if NAME is the demangled form of a C++ symbol, we will fail
 673    to find a match during the binary search of the non-encoded names, but
 674    for now we don't worry about the slight inefficiency of looking for
 675    a match we'll never find, since it will go pretty quick.  Once the
 676    binary search terminates, we drop through and do a straight linear
 677    search on the symbols.  Each symbol which is marked as being a ObjC/C++
 678    symbol (language_cplus or language_objc set) has both the encoded and
 679    non-encoded names tested for a match.  */
 680
 681 struct symbol *
 682 block_lookup_symbol (const struct block *block, const lookup_name_info &name,
 683                      const domain_search_flags domain)
 684 {
 685   if (!block->function ())
 686     {
 687       struct symbol *other = NULL;
 688
 689       for (struct symbol *sym : block_iterator_range (block, &name))
 690         {
 691           /* See comment related to PR gcc/debug/91507 in
 692              block_lookup_symbol_primary.  */
 693           if (best_symbol (sym, domain))
 694             return sym;
 695           /* This is a bit of a hack, but symbol_matches_domain might ignore
 696              STRUCT vs VAR domain symbols.  So if a matching symbol is found,
 697              make sure there is no "better" matching symbol, i.e., one with
 698              exactly the same domain.  PR 16253.  */
 699           if (sym->matches (domain))
 700             other = better_symbol (other, sym, domain);
 701         }
 702       return other;
 703     }
 704   else
 705     {
 706       /* Note that parameter symbols do not always show up last in the
 707          list; this loop makes sure to take anything else other than
 708          parameter symbols first; it only uses parameter symbols as a
 709          last resort.  Note that this only takes up extra computation
 710          time on a match.
 711          It's hard to define types in the parameter list (at least in
 712          C/C++) so we don't do the same PR 16253 hack here that is done
 713          for the !BLOCK_FUNCTION case.  */
 714
 715       struct symbol *sym_found = NULL;
 716
 717       for (struct symbol *sym : block_iterator_range (block, &name))
 718         {
 719           if (sym->matches (domain))
 720             {
 721               sym_found = sym;
 722               if (!sym->is_argument ())
 723                 {
 724                   break;
 725                 }
 726             }
 727         }
 728       return (sym_found);       /* Will be NULL if not found.  */
 729     }
 730 }
 731
 732 /* See block.h.  */
 733
 734 struct symbol *
 735 block_lookup_symbol_primary (const struct block *block, const char *name,
 736                              const domain_search_flags domain)
 737 {
 738   struct symbol *sym, *other;
 739   struct mdict_iterator mdict_iter;
 740
 741   lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
 742
 743   /* Verify BLOCK is STATIC_BLOCK or GLOBAL_BLOCK.  */
 744   gdb_assert (block->superblock () == NULL
 745               || block->superblock ()->superblock () == NULL);
 746
 747   other = NULL;
 748   for (sym = mdict_iter_match_first (block->multidict (), lookup_name,
 749                                      &mdict_iter);
 750        sym != NULL;
 751        sym = mdict_iter_match_next (lookup_name, &mdict_iter))
 752     {
 753       /* With the fix for PR gcc/debug/91507, we get for:
 754          ...
 755          extern char *zzz[];
 756          char *zzz[ ] = {
 757            "abc",
 758            "cde"
 759          };
 760          ...
 761          DWARF which will result in two entries in the symbol table, a decl
 762          with type char *[] and a def with type char *[2].
 763
 764          If we return the decl here, we don't get the value of zzz:
 765          ...
 766          $ gdb a.spec.out -batch -ex "p zzz"
 767          $1 = 0x601030 <zzz>
 768          ...
 769          because we're returning the symbol without location information, and
 770          because the fallback that uses the address from the minimal symbols
 771          doesn't work either because the type of the decl does not specify a
 772          size.
 773
 774          To fix this, we prefer def over decl in best_symbol and
 775          better_symbol.
 776
 777          In absence of the gcc fix, both def and decl have type char *[], so
 778          the only option to make this work is improve the fallback to use the
 779          size of the minimal symbol.  Filed as PR exp/24989.  */
 780       if (best_symbol (sym, domain))
 781         return sym;
 782
 783       /* This is a bit of a hack, but 'matches' might ignore
 784          STRUCT vs VAR domain symbols.  So if a matching symbol is found,
 785          make sure there is no "better" matching symbol, i.e., one with
 786          exactly the same domain.  PR 16253.  */
 787       if (sym->matches (domain))
 788         other = better_symbol (other, sym, domain);
 789     }
 790
 791   return other;
 792 }
 793
 794 /* See block.h.  */
 795
 796 struct symbol *
 797 block_find_symbol (const struct block *block, const lookup_name_info &name,
 798                    const domain_search_flags domain, struct symbol **stub)
 799 {
 800   /* Verify BLOCK is STATIC_BLOCK or GLOBAL_BLOCK.  */
 801   gdb_assert (block->superblock () == NULL
 802               || block->superblock ()->superblock () == NULL);
 803
 804   for (struct symbol *sym : block_iterator_range (block, &name))
 805     {
 806       if (!sym->matches (domain))
 807         continue;
 808
 809       if (!TYPE_IS_OPAQUE (sym->type ()))
 810         return sym;
 811
 812       if (stub != nullptr)
 813         *stub = sym;
 814     }
 815   return nullptr;
 816 }
 817
 818 /* See block.h.  */
 819
 820 struct blockranges *
 821 make_blockranges (struct objfile *objfile,
 822                   const std::vector<blockrange> &rangevec)
 823 {
 824   struct blockranges *blr;
 825   size_t n = rangevec.size();
 826
 827   blr = (struct blockranges *)
 828     obstack_alloc (&objfile->objfile_obstack,
 829                    sizeof (struct blockranges)
 830                    + (n - 1) * sizeof (struct blockrange));
 831
 832   blr->nranges = n;
 833   for (int i = 0; i < n; i++)
 834     blr->range[i] = rangevec[i];
 835   return blr;
 836 }
 837