gdb/inline-frame.c

   1 /* Inline frame unwinder for GDB.
   2
   3    Copyright (C) 2008-2013 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 "inline-frame.h"
  22 #include "addrmap.h"
  23 #include "block.h"
  24 #include "frame-unwind.h"
  25 #include "inferior.h"
  26 #include "regcache.h"
  27 #include "symtab.h"
  28 #include "vec.h"
  29
  30 #include "gdb_assert.h"
  31
  32 /* We need to save a few variables for every thread stopped at the
  33    virtual call site of an inlined function.  If there was always a
  34    "struct thread_info", we could hang it off that; in the mean time,
  35    keep our own list.  */
  36 struct inline_state
  37 {
  38   /* The thread this data relates to.  It should be a currently
  39      stopped thread; we assume thread IDs never change while the
  40      thread is stopped.  */
  41   ptid_t ptid;
  42
  43   /* The number of inlined functions we are skipping.  Each of these
  44      functions can be stepped in to.  */
  45   int skipped_frames;
  46
  47   /* Only valid if SKIPPED_FRAMES is non-zero.  This is the PC used
  48      when calculating SKIPPED_FRAMES; used to check whether we have
  49      moved to a new location by user request.  If so, we invalidate
  50      any skipped frames.  */
  51   CORE_ADDR saved_pc;
  52
  53   /* Only valid if SKIPPED_FRAMES is non-zero.  This is the symbol
  54      of the outermost skipped inline function.  It's used to find the
  55      call site of the current frame.  */
  56   struct symbol *skipped_symbol;
  57 };
  58
  59 typedef struct inline_state inline_state_s;
  60 DEF_VEC_O(inline_state_s);
  61
  62 static VEC(inline_state_s) *inline_states;
  63
  64 /* Locate saved inlined frame state for PTID, if it exists
  65    and is valid.  */
  66
  67 static struct inline_state *
  68 find_inline_frame_state (ptid_t ptid)
  69 {
  70   struct inline_state *state;
  71   int ix;
  72
  73   for (ix = 0; VEC_iterate (inline_state_s, inline_states, ix, state); ix++)
  74     {
  75       if (ptid_equal (state->ptid, ptid))
  76         {
  77           struct regcache *regcache = get_thread_regcache (ptid);
  78           CORE_ADDR current_pc = regcache_read_pc (regcache);
  79
  80           if (current_pc != state->saved_pc)
  81             {
  82               /* PC has changed - this context is invalid.  Use the
  83                  default behavior.  */
  84               VEC_unordered_remove (inline_state_s, inline_states, ix);
  85               return NULL;
  86             }
  87           else
  88             return state;
  89         }
  90     }
  91
  92   return NULL;
  93 }
  94
  95 /* Allocate saved inlined frame state for PTID.  */
  96
  97 static struct inline_state *
  98 allocate_inline_frame_state (ptid_t ptid)
  99 {
 100   struct inline_state *state;
 101
 102   state = VEC_safe_push (inline_state_s, inline_states, NULL);
 103   memset (state, 0, sizeof (*state));
 104   state->ptid = ptid;
 105
 106   return state;
 107 }
 108
 109 /* Forget about any hidden inlined functions in PTID, which is new or
 110    about to be resumed.  PTID may be minus_one_ptid (all processes)
 111    or a PID (all threads in this process).  */
 112
 113 void
 114 clear_inline_frame_state (ptid_t ptid)
 115 {
 116   struct inline_state *state;
 117   int ix;
 118
 119   if (ptid_equal (ptid, minus_one_ptid))
 120     {
 121       VEC_free (inline_state_s, inline_states);
 122       return;
 123     }
 124
 125   if (ptid_is_pid (ptid))
 126     {
 127       VEC (inline_state_s) *new_states = NULL;
 128       int pid = ptid_get_pid (ptid);
 129
 130       for (ix = 0;
 131            VEC_iterate (inline_state_s, inline_states, ix, state);
 132            ix++)
 133         if (pid != ptid_get_pid (state->ptid))
 134           VEC_safe_push (inline_state_s, new_states, state);
 135       VEC_free (inline_state_s, inline_states);
 136       inline_states = new_states;
 137       return;
 138     }
 139
 140   for (ix = 0; VEC_iterate (inline_state_s, inline_states, ix, state); ix++)
 141     if (ptid_equal (state->ptid, ptid))
 142       {
 143         VEC_unordered_remove (inline_state_s, inline_states, ix);
 144         return;
 145       }
 146 }
 147
 148 static void
 149 inline_frame_this_id (struct frame_info *this_frame,
 150                       void **this_cache,
 151                       struct frame_id *this_id)
 152 {
 153   struct symbol *func;
 154
 155   /* In order to have a stable frame ID for a given inline function,
 156      we must get the stack / special addresses from the underlying
 157      real frame's this_id method.  So we must call get_prev_frame.
 158      Because we are inlined into some function, there must be previous
 159      frames, so this is safe - as long as we're careful not to
 160      create any cycles.  */
 161   *this_id = get_frame_id (get_prev_frame (this_frame));
 162
 163   /* We need a valid frame ID, so we need to be based on a valid
 164      frame.  FSF submission NOTE: this would be a good assertion to
 165      apply to all frames, all the time.  That would fix the ambiguity
 166      of null_frame_id (between "no/any frame" and "the outermost
 167      frame").  This will take work.  */
 168   gdb_assert (frame_id_p (*this_id));
 169
 170   /* For now, require we don't match outer_frame_id either (see
 171      comment above).  */
 172   gdb_assert (!frame_id_eq (*this_id, outer_frame_id));
 173
 174   /* Future work NOTE: Alexandre Oliva applied a patch to GCC 4.3
 175      which generates DW_AT_entry_pc for inlined functions when
 176      possible.  If this attribute is available, we should use it
 177      in the frame ID (and eventually, to set breakpoints).  */
 178   func = get_frame_function (this_frame);
 179   gdb_assert (func != NULL);
 180   (*this_id).code_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (func));
 181   (*this_id).artificial_depth++;
 182 }
 183
 184 static struct value *
 185 inline_frame_prev_register (struct frame_info *this_frame, void **this_cache,
 186                             int regnum)
 187 {
 188   /* Use get_frame_register_value instead of
 189      frame_unwind_got_register, to avoid requiring this frame's ID.
 190      This frame's ID depends on the previous frame's ID (unusual), and
 191      the previous frame's ID depends on this frame's unwound
 192      registers.  If unwinding registers from this frame called
 193      get_frame_id, there would be a loop.
 194
 195      Do not copy this code into any other unwinder!  Inlined functions
 196      are special; other unwinders must not have a dependency on the
 197      previous frame's ID, and therefore can and should use
 198      frame_unwind_got_register instead.  */
 199   return get_frame_register_value (this_frame, regnum);
 200 }
 201
 202 /* Check whether we are at an inlining site that does not already
 203    have an associated frame.  */
 204
 205 static int
 206 inline_frame_sniffer (const struct frame_unwind *self,
 207                       struct frame_info *this_frame,
 208                       void **this_cache)
 209 {
 210   CORE_ADDR this_pc;
 211   struct block *frame_block, *cur_block;
 212   int depth;
 213   struct frame_info *next_frame;
 214   struct inline_state *state = find_inline_frame_state (inferior_ptid);
 215
 216   this_pc = get_frame_address_in_block (this_frame);
 217   frame_block = block_for_pc (this_pc);
 218   if (frame_block == NULL)
 219     return 0;
 220
 221   /* Calculate DEPTH, the number of inlined functions at this
 222      location.  */
 223   depth = 0;
 224   cur_block = frame_block;
 225   while (BLOCK_SUPERBLOCK (cur_block))
 226     {
 227       if (block_inlined_p (cur_block))
 228         depth++;
 229
 230       cur_block = BLOCK_SUPERBLOCK (cur_block);
 231     }
 232
 233   /* Check how many inlined functions already have frames.  */
 234   for (next_frame = get_next_frame (this_frame);
 235        next_frame && get_frame_type (next_frame) == INLINE_FRAME;
 236        next_frame = get_next_frame (next_frame))
 237     {
 238       gdb_assert (depth > 0);
 239       depth--;
 240     }
 241
 242   /* If this is the topmost frame, or all frames above us are inlined,
 243      then check whether we were requested to skip some frames (so they
 244      can be stepped into later).  */
 245   if (state != NULL && state->skipped_frames > 0 && next_frame == NULL)
 246     {
 247       gdb_assert (depth >= state->skipped_frames);
 248       depth -= state->skipped_frames;
 249     }
 250
 251   /* If all the inlined functions here already have frames, then pass
 252      to the normal unwinder for this PC.  */
 253   if (depth == 0)
 254     return 0;
 255
 256   /* If the next frame is an inlined function, but not the outermost, then
 257      we are the next outer.  If it is not an inlined function, then we
 258      are the innermost inlined function of a different real frame.  */
 259   return 1;
 260 }
 261
 262 const struct frame_unwind inline_frame_unwind = {
 263   INLINE_FRAME,
 264   default_frame_unwind_stop_reason,
 265   inline_frame_this_id,
 266   inline_frame_prev_register,
 267   NULL,
 268   inline_frame_sniffer
 269 };
 270
 271 /* Return non-zero if BLOCK, an inlined function block containing PC,
 272    has a group of contiguous instructions starting at PC (but not
 273    before it).  */
 274
 275 static int
 276 block_starting_point_at (CORE_ADDR pc, struct block *block)
 277 {
 278   struct blockvector *bv;
 279   struct block *new_block;
 280
 281   bv = blockvector_for_pc (pc, NULL);
 282   if (BLOCKVECTOR_MAP (bv) == NULL)
 283     return 0;
 284
 285   new_block = addrmap_find (BLOCKVECTOR_MAP (bv), pc - 1);
 286   if (new_block == NULL)
 287     return 1;
 288
 289   if (new_block == block || contained_in (new_block, block))
 290     return 0;
 291
 292   /* The immediately preceding address belongs to a different block,
 293      which is not a child of this one.  Treat this as an entrance into
 294      BLOCK.  */
 295   return 1;
 296 }
 297
 298 /* Skip all inlined functions whose call sites are at the current PC.
 299    Frames for the hidden functions will not appear in the backtrace until the
 300    user steps into them.  */
 301
 302 void
 303 skip_inline_frames (ptid_t ptid)
 304 {
 305   CORE_ADDR this_pc;
 306   struct block *frame_block, *cur_block;
 307   struct symbol *last_sym = NULL;
 308   int skip_count = 0;
 309   struct inline_state *state;
 310
 311   /* This function is called right after reinitializing the frame
 312      cache.  We try not to do more unwinding than absolutely
 313      necessary, for performance.  */
 314   this_pc = get_frame_pc (get_current_frame ());
 315   frame_block = block_for_pc (this_pc);
 316
 317   if (frame_block != NULL)
 318     {
 319       cur_block = frame_block;
 320       while (BLOCK_SUPERBLOCK (cur_block))
 321         {
 322           if (block_inlined_p (cur_block))
 323             {
 324               /* See comments in inline_frame_this_id about this use
 325                  of BLOCK_START.  */
 326               if (BLOCK_START (cur_block) == this_pc
 327                   || block_starting_point_at (this_pc, cur_block))
 328                 {
 329                   skip_count++;
 330                   last_sym = BLOCK_FUNCTION (cur_block);
 331                 }
 332               else
 333                 break;
 334             }
 335           cur_block = BLOCK_SUPERBLOCK (cur_block);
 336         }
 337     }
 338
 339   gdb_assert (find_inline_frame_state (ptid) == NULL);
 340   state = allocate_inline_frame_state (ptid);
 341   state->skipped_frames = skip_count;
 342   state->saved_pc = this_pc;
 343   state->skipped_symbol = last_sym;
 344
 345   if (skip_count != 0)
 346     reinit_frame_cache ();
 347 }
 348
 349 /* Step into an inlined function by unhiding it.  */
 350
 351 void
 352 step_into_inline_frame (ptid_t ptid)
 353 {
 354   struct inline_state *state = find_inline_frame_state (ptid);
 355
 356   gdb_assert (state != NULL && state->skipped_frames > 0);
 357   state->skipped_frames--;
 358   reinit_frame_cache ();
 359 }
 360
 361 /* Return the number of hidden functions inlined into the current
 362    frame.  */
 363
 364 int
 365 inline_skipped_frames (ptid_t ptid)
 366 {
 367   struct inline_state *state = find_inline_frame_state (ptid);
 368
 369   if (state == NULL)
 370     return 0;
 371   else
 372     return state->skipped_frames;
 373 }
 374
 375 /* If one or more inlined functions are hidden, return the symbol for
 376    the function inlined into the current frame.  */
 377
 378 struct symbol *
 379 inline_skipped_symbol (ptid_t ptid)
 380 {
 381   struct inline_state *state = find_inline_frame_state (ptid);
 382
 383   gdb_assert (state != NULL);
 384   return state->skipped_symbol;
 385 }
 386
 387 /* Return the number of functions inlined into THIS_FRAME.  Some of
 388    the callees may not have associated frames (see
 389    skip_inline_frames).  */
 390
 391 int
 392 frame_inlined_callees (struct frame_info *this_frame)
 393 {
 394   struct frame_info *next_frame;
 395   int inline_count = 0;
 396
 397   /* First count how many inlined functions at this PC have frames
 398      above FRAME (are inlined into FRAME).  */
 399   for (next_frame = get_next_frame (this_frame);
 400        next_frame && get_frame_type (next_frame) == INLINE_FRAME;
 401        next_frame = get_next_frame (next_frame))
 402     inline_count++;
 403
 404   /* Simulate some most-inner inlined frames which were suppressed, so
 405      they can be stepped into later.  If we are unwinding already
 406      outer frames from some non-inlined frame this does not apply.  */
 407   if (next_frame == NULL)
 408     inline_count += inline_skipped_frames (inferior_ptid);
 409
 410   return inline_count;
 411 }