gdb/dwarf2-frame-tailcall.c

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