gdb/inline-frame.c

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