GDB (xrefs)
/tmp/gdb-7.10/gdb/dwarf2-frame-tailcall.c
Go to the documentation of this file.
1 /* Virtual tail call frames unwinder for GDB.
2 
3  Copyright (C) 2010-2015 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 
32 /* Contains struct tailcall_cache indexed by next_bottom_frame. */
33 static htab_t cache_htab;
34 
35 /* Associate structure of the unwinder to call_site_chain. Lifetime of this
36  structure is maintained by REFC decremented by dealloc_cache, all of them
37  get deleted during reinit_frame_cache. */
39 {
40  /* It must be the first one of this struct. It is the furthest callee. */
42 
43  /* Reference count. The whole chain of virtual tail call frames shares one
44  tailcall_cache. */
45  int refc;
46 
47  /* Associated found virtual taill call frames chain, it is never NULL. */
49 
50  /* Cached pretended_chain_levels result. */
52 
53  /* Unwound PC from the top (caller) frame, as it is not contained
54  in CHAIN. */
56 
57  /* Compensate SP in caller frames appropriately. prev_sp and
58  entry_cfa_sp_offset are valid only if PREV_SP_P. PREV_SP is SP at the top
59  (caller) frame. ENTRY_CFA_SP_OFFSET is shift of SP in tail call frames
60  against next_bottom_frame SP. */
61  unsigned prev_sp_p : 1;
64 };
65 
66 /* hash_f for htab_create_alloc of cache_htab. */
67 
68 static hashval_t
69 cache_hash (const void *arg)
70 {
71  const struct tailcall_cache *cache = arg;
72 
73  return htab_hash_pointer (cache->next_bottom_frame);
74 }
75 
76 /* eq_f for htab_create_alloc of cache_htab. */
77 
78 static int
79 cache_eq (const void *arg1, const void *arg2)
80 {
81  const struct tailcall_cache *cache1 = arg1;
82  const struct tailcall_cache *cache2 = arg2;
83 
84  return cache1->next_bottom_frame == cache2->next_bottom_frame;
85 }
86 
87 /* Create new tailcall_cache for NEXT_BOTTOM_FRAME, NEXT_BOTTOM_FRAME must not
88  yet have been indexed by cache_htab. Caller holds one reference of the new
89  tailcall_cache. */
90 
91 static struct tailcall_cache *
93 {
94  struct tailcall_cache *cache;
95  void **slot;
96 
97  cache = xzalloc (sizeof (*cache));
98 
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
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
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 = *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
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 = *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 *
266  void **tailcall_cachep, int regnum)
267 {
268  struct gdbarch *this_gdbarch = get_frame_arch (this_frame);
269  struct tailcall_cache *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 *
296  void **this_cache, int regnum)
297 {
298  struct tailcall_cache *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
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  /* Inner tail call element does not make sense for a sentinel frame. */
324  next_frame = get_next_frame (this_frame);
325  if (next_frame == NULL)
326  return 0;
327 
328  cache = cache_find (next_frame);
329  if (cache == NULL)
330  return 0;
331 
332  cache_ref (cache);
333 
334  next_levels = existing_next_levels (this_frame, cache);
335 
336  /* NEXT_LEVELS is -1 only in dwarf2_tailcall_sniffer_first. */
337  gdb_assert (next_levels >= 0);
338  gdb_assert (next_levels <= cache->chain_levels);
339 
340  if (next_levels == cache->chain_levels)
341  {
342  cache_unref (cache);
343  return 0;
344  }
345 
346  *this_cache = cache;
347  return 1;
348 }
349 
350 /* The initial "sniffer" whether THIS_FRAME is a bottom (callee) frame of a new
351  chain to create. Keep TAILCALL_CACHEP NULL if it did not find any chain,
352  initialize it otherwise. No tail call chain is created if there are no
353  unambiguous virtual tail call frames to report.
354 
355  ENTRY_CFA_SP_OFFSETP is NULL if no special SP handling is possible,
356  otherwise *ENTRY_CFA_SP_OFFSETP is the number of bytes to subtract from tail
357  call frames frame base to get the SP value there - to simulate return
358  address pushed on the stack. */
359 
360 void
362  void **tailcall_cachep,
363  const LONGEST *entry_cfa_sp_offsetp)
364 {
365  CORE_ADDR prev_pc = 0, prev_sp = 0; /* GCC warning. */
366  int prev_sp_p = 0;
367  CORE_ADDR this_pc;
368  struct gdbarch *prev_gdbarch;
369  struct call_site_chain *chain = NULL;
370  struct tailcall_cache *cache;
371 
372  gdb_assert (*tailcall_cachep == NULL);
373 
374  /* PC may be after the function if THIS_FRAME calls noreturn function,
375  get_frame_address_in_block will decrease it by 1 in such case. */
376  this_pc = get_frame_address_in_block (this_frame);
377 
378  /* Catch any unwinding errors. */
379  TRY
380  {
381  int sp_regnum;
382 
383  prev_gdbarch = frame_unwind_arch (this_frame);
384 
385  /* Simulate frame_unwind_pc without setting this_frame->prev_pc.p. */
386  prev_pc = gdbarch_unwind_pc (prev_gdbarch, this_frame);
387 
388  /* call_site_find_chain can throw an exception. */
389  chain = call_site_find_chain (prev_gdbarch, prev_pc, this_pc);
390 
391  if (entry_cfa_sp_offsetp == NULL)
392  break;
393  sp_regnum = gdbarch_sp_regnum (prev_gdbarch);
394  if (sp_regnum == -1)
395  break;
396  prev_sp = frame_unwind_register_unsigned (this_frame, sp_regnum);
397  prev_sp_p = 1;
398  }
399  CATCH (except, RETURN_MASK_ERROR)
400  {
401  if (entry_values_debug)
402  exception_print (gdb_stdout, except);
403  return;
404  }
405  END_CATCH
406 
407  /* Ambiguous unwind or unambiguous unwind verified as matching. */
408  if (chain == NULL || chain->length == 0)
409  {
410  xfree (chain);
411  return;
412  }
413 
414  cache = cache_new_ref1 (this_frame);
415  *tailcall_cachep = cache;
416  cache->chain = chain;
417  cache->prev_pc = prev_pc;
418  cache->chain_levels = pretended_chain_levels (chain);
419  cache->prev_sp_p = prev_sp_p;
420  if (cache->prev_sp_p)
421  {
422  cache->prev_sp = prev_sp;
423  cache->entry_cfa_sp_offset = *entry_cfa_sp_offsetp;
424  }
425  gdb_assert (cache->chain_levels > 0);
426 }
427 
428 /* Implementation of frame_dealloc_cache_ftype. It can be called even for the
429  bottom chain frame from dwarf2_frame_dealloc_cache which is not a real
430  TAILCALL_FRAME. */
431 
432 static void
433 tailcall_frame_dealloc_cache (struct frame_info *self, void *this_cache)
434 {
435  struct tailcall_cache *cache = this_cache;
436 
437  cache_unref (cache);
438 }
439 
440 /* Implementation of frame_prev_arch_ftype. We assume all the virtual tail
441  call frames have gdbarch of the bottom (callee) frame. */
442 
443 static struct gdbarch *
445  void **this_prologue_cache)
446 {
447  struct tailcall_cache *cache = *this_prologue_cache;
448 
449  return get_frame_arch (cache->next_bottom_frame);
450 }
451 
452 /* Virtual tail call frame unwinder if dwarf2_tailcall_sniffer_first finds
453  a chain to create. */
454 
455 const struct frame_unwind dwarf2_tailcall_frame_unwind =
456 {
461  NULL,
465 };
466 
467 /* Provide a prototype to silence -Wmissing-prototypes. */
469 
470 void
472 {
473  cache_htab = htab_create_alloc (50, cache_hash, cache_eq, NULL, xcalloc,
474  xfree);
475 }
CORE_ADDR get_frame_address_in_block(struct frame_info *this_frame)
Definition: frame.c:2248
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
struct call_site * call_site[1]
Definition: dwarf2loc.h:278
bfd_vma CORE_ADDR
Definition: common-types.h:41
void xfree(void *)
Definition: common-utils.c:97
static int existing_next_levels(struct frame_info *this_frame, struct tailcall_cache *cache)
struct call_site_chain * chain
CORE_ADDR dwarf2_frame_cfa(struct frame_info *this_frame)
initialize_file_ftype _initialize_tailcall_frame
ULONGEST frame_unwind_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1182
struct ui_file * gdb_stdout
Definition: main.c:71
static int pretended_chain_levels(struct call_site_chain *chain)
static CORE_ADDR pretend_pc(struct frame_info *this_frame, struct tailcall_cache *cache)
#define END_CATCH
struct frame_info * next_bottom_frame
struct gdbarch * frame_unwind_arch(struct frame_info *next_frame)
Definition: frame.c:2541
#define TRY
struct frame_id get_frame_id(struct frame_info *fi)
Definition: frame.c:473
#define CATCH(EXCEPTION, MASK)
void initialize_file_ftype(void)
Definition: defs.h:281
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:1981
void * xzalloc(size_t size)
Definition: common-utils.c:91
static void cache_ref(struct tailcall_cache *cache)
static void cache_unref(struct tailcall_cache *cache)
static struct tailcall_cache * cache_new_ref1(struct frame_info *next_bottom_frame)
void exception_print(struct ui_file *file, struct gdb_exception e)
Definition: exceptions.c:109
CORE_ADDR pc
Definition: gdbtypes.h:1163
static struct gdbarch * tailcall_frame_prev_arch(struct frame_info *this_frame, void **this_prologue_cache)
CORE_ADDR gdbarch_unwind_pc(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: gdbarch.c:2853
static struct tailcall_cache * cache_find(struct frame_info *fi)
void dwarf2_tailcall_sniffer_first(struct frame_info *this_frame, void **tailcall_cachep, const LONGEST *entry_cfa_sp_offsetp)
#define gdb_assert(expr)
Definition: gdb_assert.h:33
int regnum
Definition: aarch64-tdep.c:69
static hashval_t cache_hash(const void *arg)
static struct value * tailcall_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
static int frame_is_tailcall(struct frame_info *fi)
static void tailcall_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
Definition: value.c:172
struct frame_info * get_next_frame(struct frame_info *this_frame)
Definition: frame.c:1668
int frame_relative_level(struct frame_info *fi)
Definition: frame.c:2454
static void tailcall_frame_dealloc_cache(struct frame_info *self, void *this_cache)
struct value * frame_unwind_got_register(struct frame_info *frame, int regnum, int new_regnum)
Definition: frame-unwind.c:218
static htab_t cache_htab
struct value * dwarf2_tailcall_prev_register_first(struct frame_info *this_frame, void **tailcall_cachep, int regnum)
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:180
unsigned int entry_values_debug
Definition: dwarf2loc.c:509
struct value * frame_unwind_got_address(struct frame_info *frame, int regnum, CORE_ADDR addr)
Definition: frame-unwind.c:270
static int tailcall_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_cache)
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:1998
static int cache_eq(const void *arg1, const void *arg2)
PTR xcalloc(size_t number, size_t size)
Definition: common-utils.c:71
struct call_site_chain * call_site_find_chain(struct gdbarch *gdbarch, CORE_ADDR caller_pc, CORE_ADDR callee_pc)
Definition: dwarf2loc.c:982
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
long long LONGEST
Definition: common-types.h:52
int frame_unwinder_is(struct frame_info *fi, const struct frame_unwind *unwinder)
Definition: frame.c:2443