gdb/dwarf2-frame-tailcall.c

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