gdb/block.c

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