gdb/block.c

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