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