gdb/dwarf2/frame-tailcall.c

   1 /* Virtual tail call frames unwinder for GDB.
   2
   3    Copyright (C) 2010-2024 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "frame.h"
  22 #include "dwarf2/frame-tailcall.h"
  23 #include "dwarf2/loc.h"
  24 #include "frame-unwind.h"
  25 #include "block.h"
  26 #include "hashtab.h"
  27 #include "gdbtypes.h"
  28 #include "regcache.h"
  29 #include "value.h"
  30 #include "dwarf2/frame.h"
  31 #include "gdbarch.h"
  32
  33 /* Contains struct tailcall_cache indexed by next_bottom_frame.  */
  34 static htab_t cache_htab;
  35
  36 /* Associate structure of the unwinder to call_site_chain.  Lifetime of this
  37    structure is maintained by REFC decremented by dealloc_cache, all of them
  38    get deleted during reinit_frame_cache.  */
  39 struct tailcall_cache
  40 {
  41   /* It must be the first one of this struct.  It is the furthest callee.  */
  42   frame_info *next_bottom_frame;
  43
  44   /* Reference count.  The whole chain of virtual tail call frames shares one
  45      tailcall_cache.  */
  46   int refc;
  47
  48   /* Associated found virtual tail call frames chain, it is never NULL.  */
  49   struct call_site_chain *chain;
  50
  51   /* Cached pretended_chain_levels result.  */
  52   int chain_levels;
  53
  54   /* Unwound PC from the top (caller) frame, as it is not contained
  55      in CHAIN.  */
  56   CORE_ADDR prev_pc;
  57
  58   /* Compensate SP in caller frames appropriately.  prev_sp and
  59      entry_cfa_sp_offset are valid only if PREV_SP_P.  PREV_SP is SP at the top
  60      (caller) frame.  ENTRY_CFA_SP_OFFSET is shift of SP in tail call frames
  61      against next_bottom_frame SP.  */
  62   unsigned prev_sp_p : 1;
  63   CORE_ADDR prev_sp;
  64   LONGEST entry_cfa_sp_offset;
  65 };
  66
  67 /* hash_f for htab_create_alloc of cache_htab.  */
  68
  69 static hashval_t
  70 cache_hash (const void *arg)
  71 {
  72   const struct tailcall_cache *cache = (const struct tailcall_cache *) arg;
  73
  74   return htab_hash_pointer (cache->next_bottom_frame);
  75 }
  76
  77 /* eq_f for htab_create_alloc of cache_htab.  */
  78
  79 static int
  80 cache_eq (const void *arg1, const void *arg2)
  81 {
  82   const struct tailcall_cache *cache1 = (const struct tailcall_cache *) arg1;
  83   const struct tailcall_cache *cache2 = (const struct tailcall_cache *) arg2;
  84
  85   return cache1->next_bottom_frame == cache2->next_bottom_frame;
  86 }
  87
  88 /* Create new tailcall_cache for NEXT_BOTTOM_FRAME, NEXT_BOTTOM_FRAME must not
  89    yet have been indexed by cache_htab.  Caller holds one reference of the new
  90    tailcall_cache.  */
  91
  92 static struct tailcall_cache *
  93 cache_new_ref1 (const frame_info_ptr &next_bottom_frame)
  94 {
  95   struct tailcall_cache *cache = XCNEW (struct tailcall_cache);
  96   void **slot;
  97
  98   cache->next_bottom_frame = next_bottom_frame.get ();
  99   cache->refc = 1;
 100
 101   slot = htab_find_slot (cache_htab, cache, INSERT);
 102   gdb_assert (*slot == NULL);
 103   *slot = cache;
 104
 105   return cache;
 106 }
 107
 108 /* Create new reference to CACHE.  */
 109
 110 static void
 111 cache_ref (struct tailcall_cache *cache)
 112 {
 113   gdb_assert (cache->refc > 0);
 114
 115   cache->refc++;
 116 }
 117
 118 /* Drop reference to CACHE, possibly fully freeing it and unregistering it from
 119    cache_htab.  */
 120
 121 static void
 122 cache_unref (struct tailcall_cache *cache)
 123 {
 124   gdb_assert (cache->refc > 0);
 125
 126   if (!--cache->refc)
 127     {
 128       gdb_assert (htab_find_slot (cache_htab, cache, NO_INSERT) != NULL);
 129       htab_remove_elt (cache_htab, cache);
 130
 131       xfree (cache->chain);
 132       xfree (cache);
 133     }
 134 }
 135
 136 /* Return 1 if FI is a non-bottom (not the callee) tail call frame.  Otherwise
 137    return 0.  */
 138
 139 static int
 140 frame_is_tailcall (const frame_info_ptr &fi)
 141 {
 142   return frame_unwinder_is (fi, &dwarf2_tailcall_frame_unwind);
 143 }
 144
 145 /* Try to find tailcall_cache in cache_htab if FI is a part of its virtual tail
 146    call chain.  Otherwise return NULL.  No new reference is created.  */
 147
 148 static struct tailcall_cache *
 149 cache_find (const frame_info_ptr &initial_fi)
 150 {
 151   struct tailcall_cache *cache;
 152   struct tailcall_cache search;
 153   void **slot;
 154
 155   frame_info_ptr fi = initial_fi;
 156   while (frame_is_tailcall (fi))
 157     {
 158       fi = get_next_frame (fi);
 159       gdb_assert (fi != NULL);
 160     }
 161
 162   search.next_bottom_frame = fi.get();
 163   search.refc = 1;
 164   slot = htab_find_slot (cache_htab, &search, NO_INSERT);
 165   if (slot == NULL)
 166     return NULL;
 167
 168   cache = (struct tailcall_cache *) *slot;
 169   gdb_assert (cache != NULL);
 170   return cache;
 171 }
 172
 173 /* Number of virtual frames between THIS_FRAME and CACHE->NEXT_BOTTOM_FRAME.
 174    If THIS_FRAME is CACHE-> NEXT_BOTTOM_FRAME return -1.  */
 175
 176 static int
 177 existing_next_levels (const frame_info_ptr &this_frame,
 178                       struct tailcall_cache *cache)
 179 {
 180   int retval = (frame_relative_level (this_frame)
 181                 - frame_relative_level (frame_info_ptr (cache->next_bottom_frame)) - 1);
 182
 183   gdb_assert (retval >= -1);
 184
 185   return retval;
 186 }
 187
 188 /* The number of virtual tail call frames in CHAIN.  With no virtual tail call
 189    frames the function would return 0 (but CHAIN does not exist in such
 190    case).  */
 191
 192 static int
 193 pretended_chain_levels (struct call_site_chain *chain)
 194 {
 195   int chain_levels;
 196
 197   gdb_assert (chain != NULL);
 198
 199   if (chain->callers == chain->length && chain->callees == chain->length)
 200     return chain->length;
 201
 202   chain_levels = chain->callers + chain->callees;
 203   gdb_assert (chain_levels <= chain->length);
 204
 205   return chain_levels;
 206 }
 207
 208 /* Implementation of frame_this_id_ftype.  THIS_CACHE must be already
 209    initialized with tailcall_cache, THIS_FRAME must be a part of THIS_CACHE.
 210
 211    Specific virtual tail call frames are tracked by INLINE_DEPTH.  */
 212
 213 static void
 214 tailcall_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
 215                         struct frame_id *this_id)
 216 {
 217   struct tailcall_cache *cache = (struct tailcall_cache *) *this_cache;
 218   frame_info_ptr next_frame;
 219
 220   /* Tail call does not make sense for a sentinel frame.  */
 221   next_frame = get_next_frame (this_frame);
 222   gdb_assert (next_frame != NULL);
 223
 224   *this_id = get_frame_id (next_frame);
 225   (*this_id).code_addr = get_frame_pc (this_frame);
 226   (*this_id).code_addr_p = true;
 227   (*this_id).artificial_depth = (cache->chain_levels
 228                                  - existing_next_levels (this_frame, cache));
 229   gdb_assert ((*this_id).artificial_depth > 0);
 230 }
 231
 232 /* Find PC to be unwound from THIS_FRAME.  THIS_FRAME must be a part of
 233    CACHE.  */
 234
 235 static CORE_ADDR
 236 pretend_pc (const frame_info_ptr &this_frame, struct tailcall_cache *cache)
 237 {
 238   int next_levels = existing_next_levels (this_frame, cache);
 239   struct call_site_chain *chain = cache->chain;
 240
 241   gdb_assert (chain != NULL);
 242
 243   next_levels++;
 244   gdb_assert (next_levels >= 0);
 245
 246   if (next_levels < chain->callees)
 247     return chain->call_site[chain->length - next_levels - 1]->pc ();
 248   next_levels -= chain->callees;
 249
 250   /* Otherwise CHAIN->CALLEES are already covered by CHAIN->CALLERS.  */
 251   if (chain->callees != chain->length)
 252     {
 253       if (next_levels < chain->callers)
 254         return chain->call_site[chain->callers - next_levels - 1]->pc ();
 255       next_levels -= chain->callers;
 256     }
 257
 258   gdb_assert (next_levels == 0);
 259   return cache->prev_pc;
 260 }
 261
 262 /* Implementation of frame_prev_register_ftype.  If no specific register
 263    override is supplied NULL is returned (this is incompatible with
 264    frame_prev_register_ftype semantics).  next_bottom_frame and tail call
 265    frames unwind the NULL case differently.  */
 266
 267 struct value *
 268 dwarf2_tailcall_prev_register_first (const frame_info_ptr &this_frame,
 269                                      void **tailcall_cachep, int regnum)
 270 {
 271   struct gdbarch *this_gdbarch = get_frame_arch (this_frame);
 272   struct tailcall_cache *cache = (struct tailcall_cache *) *tailcall_cachep;
 273   CORE_ADDR addr;
 274
 275   if (regnum == gdbarch_pc_regnum (this_gdbarch))
 276     addr = pretend_pc (this_frame, cache);
 277   else if (cache->prev_sp_p && regnum == gdbarch_sp_regnum (this_gdbarch))
 278     {
 279       int next_levels = existing_next_levels (this_frame, cache);
 280
 281       if (next_levels == cache->chain_levels - 1)
 282         addr = cache->prev_sp;
 283       else
 284         addr = dwarf2_frame_cfa (this_frame) - cache->entry_cfa_sp_offset;
 285     }
 286   else
 287     return NULL;
 288
 289   return frame_unwind_got_address (this_frame, regnum, addr);
 290 }
 291
 292 /* Implementation of frame_prev_register_ftype for tail call frames.  Register
 293    set of virtual tail call frames is assumed to be the one of the top (caller)
 294    frame - assume unchanged register value for NULL from
 295    dwarf2_tailcall_prev_register_first.  */
 296
 297 static struct value *
 298 tailcall_frame_prev_register (const frame_info_ptr &this_frame,
 299                                void **this_cache, int regnum)
 300 {
 301   struct tailcall_cache *cache = (struct tailcall_cache *) *this_cache;
 302   struct value *val;
 303
 304   gdb_assert (this_frame != cache->next_bottom_frame);
 305
 306   val = dwarf2_tailcall_prev_register_first (this_frame, this_cache, regnum);
 307   if (val)
 308     return val;
 309
 310   return frame_unwind_got_register (this_frame, regnum, regnum);
 311 }
 312
 313 /* Implementation of frame_sniffer_ftype.  It will never find a new chain, use
 314    dwarf2_tailcall_sniffer_first for the bottom (callee) frame.  It will find
 315    all the predecessing virtual tail call frames, it will return false when
 316    there exist no more tail call frames in this chain.  */
 317
 318 static int
 319 tailcall_frame_sniffer (const struct frame_unwind *self,
 320                          const frame_info_ptr &this_frame, void **this_cache)
 321 {
 322   frame_info_ptr next_frame;
 323   int next_levels;
 324   struct tailcall_cache *cache;
 325
 326   if (!dwarf2_frame_unwinders_enabled_p)
 327     return 0;
 328
 329   /* Inner tail call element does not make sense for a sentinel frame.  */
 330   next_frame = get_next_frame (this_frame);
 331   if (next_frame == NULL)
 332     return 0;
 333
 334   cache = cache_find (next_frame);
 335   if (cache == NULL)
 336     return 0;
 337
 338   cache_ref (cache);
 339
 340   next_levels = existing_next_levels (this_frame, cache);
 341
 342   /* NEXT_LEVELS is -1 only in dwarf2_tailcall_sniffer_first.  */
 343   gdb_assert (next_levels >= 0);
 344   gdb_assert (next_levels <= cache->chain_levels);
 345
 346   if (next_levels == cache->chain_levels)
 347     {
 348       cache_unref (cache);
 349       return 0;
 350     }
 351
 352   *this_cache = cache;
 353   return 1;
 354 }
 355
 356 /* The initial "sniffer" whether THIS_FRAME is a bottom (callee) frame of a new
 357    chain to create.  Keep TAILCALL_CACHEP NULL if it did not find any chain,
 358    initialize it otherwise.  No tail call chain is created if there are no
 359    unambiguous virtual tail call frames to report.
 360
 361    ENTRY_CFA_SP_OFFSETP is NULL if no special SP handling is possible,
 362    otherwise *ENTRY_CFA_SP_OFFSETP is the number of bytes to subtract from tail
 363    call frames frame base to get the SP value there - to simulate return
 364    address pushed on the stack.  */
 365
 366 void
 367 dwarf2_tailcall_sniffer_first (const frame_info_ptr &this_frame,
 368                                void **tailcall_cachep,
 369                                const LONGEST *entry_cfa_sp_offsetp)
 370 {
 371   CORE_ADDR prev_pc = 0, prev_sp = 0;   /* GCC warning.  */
 372   int prev_sp_p = 0;
 373   CORE_ADDR this_pc;
 374   struct gdbarch *prev_gdbarch;
 375   gdb::unique_xmalloc_ptr<call_site_chain> chain;
 376   struct tailcall_cache *cache;
 377
 378   gdb_assert (*tailcall_cachep == NULL);
 379
 380   /* PC may be after the function if THIS_FRAME calls noreturn function,
 381      get_frame_address_in_block will decrease it by 1 in such case.  */
 382   this_pc = get_frame_address_in_block (this_frame);
 383
 384   try
 385     {
 386       int sp_regnum;
 387
 388       prev_gdbarch = frame_unwind_arch (this_frame);
 389
 390       /* Simulate frame_unwind_pc without setting this_frame->prev_pc.p.  */
 391       prev_pc = gdbarch_unwind_pc (prev_gdbarch, this_frame);
 392
 393       /* call_site_find_chain can throw an exception.  */
 394       chain = call_site_find_chain (prev_gdbarch, prev_pc, this_pc);
 395
 396       if (entry_cfa_sp_offsetp != NULL)
 397         {
 398           sp_regnum = gdbarch_sp_regnum (prev_gdbarch);
 399           if (sp_regnum != -1)
 400             {
 401               prev_sp = frame_unwind_register_unsigned (this_frame, sp_regnum);
 402               prev_sp_p = 1;
 403             }
 404         }
 405     }
 406   catch (const gdb_exception_error &except)
 407     {
 408       if (entry_values_debug)
 409         exception_print (gdb_stdout, except);
 410
 411       switch (except.error)
 412         {
 413         case NO_ENTRY_VALUE_ERROR:
 414           /* Thrown by call_site_find_chain.  */
 415         case MEMORY_ERROR:
 416         case OPTIMIZED_OUT_ERROR:
 417         case NOT_AVAILABLE_ERROR:
 418           /* These can normally happen when we try to access an
 419              optimized out or unavailable register, either in a
 420              physical register or spilled to memory.  */
 421           return;
 422         }
 423
 424       /* Let unexpected errors propagate.  */
 425       throw;
 426     }
 427
 428   /* Ambiguous unwind or unambiguous unwind verified as matching.  */
 429   if (chain == NULL || chain->length == 0)
 430     return;
 431
 432   cache = cache_new_ref1 (this_frame);
 433   *tailcall_cachep = cache;
 434   cache->chain = chain.release ();
 435   cache->prev_pc = prev_pc;
 436   cache->chain_levels = pretended_chain_levels (cache->chain);
 437   cache->prev_sp_p = prev_sp_p;
 438   if (cache->prev_sp_p)
 439     {
 440       cache->prev_sp = prev_sp;
 441       cache->entry_cfa_sp_offset = *entry_cfa_sp_offsetp;
 442     }
 443   gdb_assert (cache->chain_levels > 0);
 444 }
 445
 446 /* Implementation of frame_dealloc_cache_ftype.  It can be called even for the
 447    bottom chain frame from dwarf2_frame_dealloc_cache which is not a real
 448    TAILCALL_FRAME.  */
 449
 450 static void
 451 tailcall_frame_dealloc_cache (frame_info *self, void *this_cache)
 452 {
 453   struct tailcall_cache *cache = (struct tailcall_cache *) this_cache;
 454
 455   cache_unref (cache);
 456 }
 457
 458 /* Implementation of frame_prev_arch_ftype.  We assume all the virtual tail
 459    call frames have gdbarch of the bottom (callee) frame.  */
 460
 461 static struct gdbarch *
 462 tailcall_frame_prev_arch (const frame_info_ptr &this_frame,
 463                           void **this_prologue_cache)
 464 {
 465   struct tailcall_cache *cache = (struct tailcall_cache *) *this_prologue_cache;
 466
 467   return get_frame_arch (frame_info_ptr (cache->next_bottom_frame));
 468 }
 469
 470 /* Virtual tail call frame unwinder if dwarf2_tailcall_sniffer_first finds
 471    a chain to create.  */
 472
 473 const struct frame_unwind dwarf2_tailcall_frame_unwind =
 474 {
 475   "dwarf2 tailcall",
 476   TAILCALL_FRAME,
 477   default_frame_unwind_stop_reason,
 478   tailcall_frame_this_id,
 479   tailcall_frame_prev_register,
 480   NULL,
 481   tailcall_frame_sniffer,
 482   tailcall_frame_dealloc_cache,
 483   tailcall_frame_prev_arch
 484 };
 485
 486 void _initialize_tailcall_frame ();
 487 void
 488 _initialize_tailcall_frame ()
 489 {
 490   cache_htab = htab_create_alloc (50, cache_hash, cache_eq, NULL, xcalloc,
 491                                   xfree);
 492 }