gdb/dwarf2/frame-tailcall.c

   1 /* Virtual tail call frames unwinder for GDB.
   2
   3    Copyright (C) 2010-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 "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 (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 (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 (frame_info_ptr fi)
 150 {
 151   struct tailcall_cache *cache;
 152   struct tailcall_cache search;
 153   void **slot;
 154
 155   while (frame_is_tailcall (fi))
 156     {
 157       fi = get_next_frame (fi);
 158       gdb_assert (fi != NULL);
 159     }
 160
 161   search.next_bottom_frame = fi.get();
 162   search.refc = 1;
 163   slot = htab_find_slot (cache_htab, &search, NO_INSERT);
 164   if (slot == NULL)
 165     return NULL;
 166
 167   cache = (struct tailcall_cache *) *slot;
 168   gdb_assert (cache != NULL);
 169   return cache;
 170 }
 171
 172 /* Number of virtual frames between THIS_FRAME and CACHE->NEXT_BOTTOM_FRAME.
 173    If THIS_FRAME is CACHE-> NEXT_BOTTOM_FRAME return -1.  */
 174
 175 static int
 176 existing_next_levels (frame_info_ptr this_frame,
 177                       struct tailcall_cache *cache)
 178 {
 179   int retval = (frame_relative_level (this_frame)
 180                 - frame_relative_level (frame_info_ptr (cache->next_bottom_frame)) - 1);
 181
 182   gdb_assert (retval >= -1);
 183
 184   return retval;
 185 }
 186
 187 /* The number of virtual tail call frames in CHAIN.  With no virtual tail call
 188    frames the function would return 0 (but CHAIN does not exist in such
 189    case).  */
 190
 191 static int
 192 pretended_chain_levels (struct call_site_chain *chain)
 193 {
 194   int chain_levels;
 195
 196   gdb_assert (chain != NULL);
 197
 198   if (chain->callers == chain->length && chain->callees == chain->length)
 199     return chain->length;
 200
 201   chain_levels = chain->callers + chain->callees;
 202   gdb_assert (chain_levels <= chain->length);
 203
 204   return chain_levels;
 205 }
 206
 207 /* Implementation of frame_this_id_ftype.  THIS_CACHE must be already
 208    initialized with tailcall_cache, THIS_FRAME must be a part of THIS_CACHE.
 209
 210    Specific virtual tail call frames are tracked by INLINE_DEPTH.  */
 211
 212 static void
 213 tailcall_frame_this_id (frame_info_ptr this_frame, void **this_cache,
 214                         struct frame_id *this_id)
 215 {
 216   struct tailcall_cache *cache = (struct tailcall_cache *) *this_cache;
 217   frame_info_ptr next_frame;
 218
 219   /* Tail call does not make sense for a sentinel frame.  */
 220   next_frame = get_next_frame (this_frame);
 221   gdb_assert (next_frame != NULL);
 222
 223   *this_id = get_frame_id (next_frame);
 224   (*this_id).code_addr = get_frame_pc (this_frame);
 225   (*this_id).code_addr_p = true;
 226   (*this_id).artificial_depth = (cache->chain_levels
 227                                  - existing_next_levels (this_frame, cache));
 228   gdb_assert ((*this_id).artificial_depth > 0);
 229 }
 230
 231 /* Find PC to be unwound from THIS_FRAME.  THIS_FRAME must be a part of
 232    CACHE.  */
 233
 234 static CORE_ADDR
 235 pretend_pc (frame_info_ptr this_frame, struct tailcall_cache *cache)
 236 {
 237   int next_levels = existing_next_levels (this_frame, cache);
 238   struct call_site_chain *chain = cache->chain;
 239
 240   gdb_assert (chain != NULL);
 241
 242   next_levels++;
 243   gdb_assert (next_levels >= 0);
 244
 245   if (next_levels < chain->callees)
 246     return chain->call_site[chain->length - next_levels - 1]->pc ();
 247   next_levels -= chain->callees;
 248
 249   /* Otherwise CHAIN->CALLEES are already covered by CHAIN->CALLERS.  */
 250   if (chain->callees != chain->length)
 251     {
 252       if (next_levels < chain->callers)
 253         return chain->call_site[chain->callers - next_levels - 1]->pc ();
 254       next_levels -= chain->callers;
 255     }
 256
 257   gdb_assert (next_levels == 0);
 258   return cache->prev_pc;
 259 }
 260
 261 /* Implementation of frame_prev_register_ftype.  If no specific register
 262    override is supplied NULL is returned (this is incompatible with
 263    frame_prev_register_ftype semantics).  next_bottom_frame and tail call
 264    frames unwind the NULL case differently.  */
 265
 266 struct value *
 267 dwarf2_tailcall_prev_register_first (frame_info_ptr this_frame,
 268                                      void **tailcall_cachep, int regnum)
 269 {
 270   struct gdbarch *this_gdbarch = get_frame_arch (this_frame);
 271   struct tailcall_cache *cache = (struct tailcall_cache *) *tailcall_cachep;
 272   CORE_ADDR addr;
 273
 274   if (regnum == gdbarch_pc_regnum (this_gdbarch))
 275     addr = pretend_pc (this_frame, cache);
 276   else if (cache->prev_sp_p && regnum == gdbarch_sp_regnum (this_gdbarch))
 277     {
 278       int next_levels = existing_next_levels (this_frame, cache);
 279
 280       if (next_levels == cache->chain_levels - 1)
 281         addr = cache->prev_sp;
 282       else
 283         addr = dwarf2_frame_cfa (this_frame) - cache->entry_cfa_sp_offset;
 284     }
 285   else
 286     return NULL;
 287
 288   return frame_unwind_got_address (this_frame, regnum, addr);
 289 }
 290
 291 /* Implementation of frame_prev_register_ftype for tail call frames.  Register
 292    set of virtual tail call frames is assumed to be the one of the top (caller)
 293    frame - assume unchanged register value for NULL from
 294    dwarf2_tailcall_prev_register_first.  */
 295
 296 static struct value *
 297 tailcall_frame_prev_register (frame_info_ptr this_frame,
 298                                void **this_cache, int regnum)
 299 {
 300   struct tailcall_cache *cache = (struct tailcall_cache *) *this_cache;
 301   struct value *val;
 302
 303   gdb_assert (this_frame != cache->next_bottom_frame);
 304
 305   val = dwarf2_tailcall_prev_register_first (this_frame, this_cache, regnum);
 306   if (val)
 307     return val;
 308
 309   return frame_unwind_got_register (this_frame, regnum, regnum);
 310 }
 311
 312 /* Implementation of frame_sniffer_ftype.  It will never find a new chain, use
 313    dwarf2_tailcall_sniffer_first for the bottom (callee) frame.  It will find
 314    all the predecessing virtual tail call frames, it will return false when
 315    there exist no more tail call frames in this chain.  */
 316
 317 static int
 318 tailcall_frame_sniffer (const struct frame_unwind *self,
 319                          frame_info_ptr this_frame, void **this_cache)
 320 {
 321   frame_info_ptr next_frame;
 322   int next_levels;
 323   struct tailcall_cache *cache;
 324
 325   if (!dwarf2_frame_unwinders_enabled_p)
 326     return 0;
 327
 328   /* Inner tail call element does not make sense for a sentinel frame.  */
 329   next_frame = get_next_frame (this_frame);
 330   if (next_frame == NULL)
 331     return 0;
 332
 333   cache = cache_find (next_frame);
 334   if (cache == NULL)
 335     return 0;
 336
 337   cache_ref (cache);
 338
 339   next_levels = existing_next_levels (this_frame, cache);
 340
 341   /* NEXT_LEVELS is -1 only in dwarf2_tailcall_sniffer_first.  */
 342   gdb_assert (next_levels >= 0);
 343   gdb_assert (next_levels <= cache->chain_levels);
 344
 345   if (next_levels == cache->chain_levels)
 346     {
 347       cache_unref (cache);
 348       return 0;
 349     }
 350
 351   *this_cache = cache;
 352   return 1;
 353 }
 354
 355 /* The initial "sniffer" whether THIS_FRAME is a bottom (callee) frame of a new
 356    chain to create.  Keep TAILCALL_CACHEP NULL if it did not find any chain,
 357    initialize it otherwise.  No tail call chain is created if there are no
 358    unambiguous virtual tail call frames to report.
 359
 360    ENTRY_CFA_SP_OFFSETP is NULL if no special SP handling is possible,
 361    otherwise *ENTRY_CFA_SP_OFFSETP is the number of bytes to subtract from tail
 362    call frames frame base to get the SP value there - to simulate return
 363    address pushed on the stack.  */
 364
 365 void
 366 dwarf2_tailcall_sniffer_first (frame_info_ptr this_frame,
 367                                void **tailcall_cachep,
 368                                const LONGEST *entry_cfa_sp_offsetp)
 369 {
 370   CORE_ADDR prev_pc = 0, prev_sp = 0;   /* GCC warning.  */
 371   int prev_sp_p = 0;
 372   CORE_ADDR this_pc;
 373   struct gdbarch *prev_gdbarch;
 374   gdb::unique_xmalloc_ptr<call_site_chain> chain;
 375   struct tailcall_cache *cache;
 376
 377   gdb_assert (*tailcall_cachep == NULL);
 378
 379   /* PC may be after the function if THIS_FRAME calls noreturn function,
 380      get_frame_address_in_block will decrease it by 1 in such case.  */
 381   this_pc = get_frame_address_in_block (this_frame);
 382
 383   try
 384     {
 385       int sp_regnum;
 386
 387       prev_gdbarch = frame_unwind_arch (this_frame);
 388
 389       /* Simulate frame_unwind_pc without setting this_frame->prev_pc.p.  */
 390       prev_pc = gdbarch_unwind_pc (prev_gdbarch, this_frame);
 391
 392       /* call_site_find_chain can throw an exception.  */
 393       chain = call_site_find_chain (prev_gdbarch, prev_pc, this_pc);
 394
 395       if (entry_cfa_sp_offsetp != NULL)
 396         {
 397           sp_regnum = gdbarch_sp_regnum (prev_gdbarch);
 398           if (sp_regnum != -1)
 399             {
 400               prev_sp = frame_unwind_register_unsigned (this_frame, sp_regnum);
 401               prev_sp_p = 1;
 402             }
 403         }
 404     }
 405   catch (const gdb_exception_error &except)
 406     {
 407       if (entry_values_debug)
 408         exception_print (gdb_stdout, except);
 409
 410       switch (except.error)
 411         {
 412         case NO_ENTRY_VALUE_ERROR:
 413           /* Thrown by call_site_find_chain.  */
 414         case MEMORY_ERROR:
 415         case OPTIMIZED_OUT_ERROR:
 416         case NOT_AVAILABLE_ERROR:
 417           /* These can normally happen when we try to access an
 418              optimized out or unavailable register, either in a
 419              physical register or spilled to memory.  */
 420           return;
 421         }
 422
 423       /* Let unexpected errors propagate.  */
 424       throw;
 425     }
 426
 427   /* Ambiguous unwind or unambiguous unwind verified as matching.  */
 428   if (chain == NULL || chain->length == 0)
 429     return;
 430
 431   cache = cache_new_ref1 (this_frame);
 432   *tailcall_cachep = cache;
 433   cache->chain = chain.release ();
 434   cache->prev_pc = prev_pc;
 435   cache->chain_levels = pretended_chain_levels (cache->chain);
 436   cache->prev_sp_p = prev_sp_p;
 437   if (cache->prev_sp_p)
 438     {
 439       cache->prev_sp = prev_sp;
 440       cache->entry_cfa_sp_offset = *entry_cfa_sp_offsetp;
 441     }
 442   gdb_assert (cache->chain_levels > 0);
 443 }
 444
 445 /* Implementation of frame_dealloc_cache_ftype.  It can be called even for the
 446    bottom chain frame from dwarf2_frame_dealloc_cache which is not a real
 447    TAILCALL_FRAME.  */
 448
 449 static void
 450 tailcall_frame_dealloc_cache (frame_info *self, void *this_cache)
 451 {
 452   struct tailcall_cache *cache = (struct tailcall_cache *) this_cache;
 453
 454   cache_unref (cache);
 455 }
 456
 457 /* Implementation of frame_prev_arch_ftype.  We assume all the virtual tail
 458    call frames have gdbarch of the bottom (callee) frame.  */
 459
 460 static struct gdbarch *
 461 tailcall_frame_prev_arch (frame_info_ptr this_frame,
 462                           void **this_prologue_cache)
 463 {
 464   struct tailcall_cache *cache = (struct tailcall_cache *) *this_prologue_cache;
 465
 466   return get_frame_arch (frame_info_ptr (cache->next_bottom_frame));
 467 }
 468
 469 /* Virtual tail call frame unwinder if dwarf2_tailcall_sniffer_first finds
 470    a chain to create.  */
 471
 472 const struct frame_unwind dwarf2_tailcall_frame_unwind =
 473 {
 474   "dwarf2 tailcall",
 475   TAILCALL_FRAME,
 476   default_frame_unwind_stop_reason,
 477   tailcall_frame_this_id,
 478   tailcall_frame_prev_register,
 479   NULL,
 480   tailcall_frame_sniffer,
 481   tailcall_frame_dealloc_cache,
 482   tailcall_frame_prev_arch
 483 };
 484
 485 void _initialize_tailcall_frame ();
 486 void
 487 _initialize_tailcall_frame ()
 488 {
 489   cache_htab = htab_create_alloc (50, cache_hash, cache_eq, NULL, xcalloc,
 490                                   xfree);
 491 }