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