1 /* Virtual tail call frames unwinder for GDB.
3 Copyright (C) 2010-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
22 #include "dwarf2-frame-tailcall.h"
23 #include "dwarf2loc.h"
24 #include "frame-unwind.h"
30 #include "dwarf2-frame.h"
32 /* Contains struct tailcall_cache indexed by next_bottom_frame. */
33 static htab_t cache_htab;
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. */
40 /* It must be the first one of this struct. It is the furthest callee. */
41 struct frame_info *next_bottom_frame;
43 /* Reference count. The whole chain of virtual tail call frames shares one
47 /* Associated found virtual taill call frames chain, it is never NULL. */
48 struct call_site_chain *chain;
50 /* Cached pretended_chain_levels result. */
53 /* Unwound PC from the top (caller) frame, as it is not contained
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;
63 LONGEST entry_cfa_sp_offset;
66 /* hash_f for htab_create_alloc of cache_htab. */
69 cache_hash (const void *arg)
71 const struct tailcall_cache *cache = arg;
73 return htab_hash_pointer (cache->next_bottom_frame);
76 /* eq_f for htab_create_alloc of cache_htab. */
79 cache_eq (const void *arg1, const void *arg2)
81 const struct tailcall_cache *cache1 = arg1;
82 const struct tailcall_cache *cache2 = arg2;
84 return cache1->next_bottom_frame == cache2->next_bottom_frame;
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
91 static struct tailcall_cache *
92 cache_new_ref1 (struct frame_info *next_bottom_frame)
94 struct tailcall_cache *cache;
97 cache = xzalloc (sizeof (*cache));
99 cache->next_bottom_frame = next_bottom_frame;
102 slot = htab_find_slot (cache_htab, cache, INSERT);
103 gdb_assert (*slot == NULL);
109 /* Create new reference to CACHE. */
112 cache_ref (struct tailcall_cache *cache)
114 gdb_assert (cache->refc > 0);
119 /* Drop reference to CACHE, possibly fully freeing it and unregistering it from
123 cache_unref (struct tailcall_cache *cache)
125 gdb_assert (cache->refc > 0);
129 gdb_assert (htab_find_slot (cache_htab, cache, NO_INSERT) != NULL);
130 htab_remove_elt (cache_htab, cache);
132 xfree (cache->chain);
137 /* Return 1 if FI is a non-bottom (not the callee) tail call frame. Otherwise
141 frame_is_tailcall (struct frame_info *fi)
143 return frame_unwinder_is (fi, &dwarf2_tailcall_frame_unwind);
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. */
149 static struct tailcall_cache *
150 cache_find (struct frame_info *fi)
152 struct tailcall_cache *cache;
155 while (frame_is_tailcall (fi))
157 fi = get_next_frame (fi);
158 gdb_assert (fi != NULL);
161 slot = htab_find_slot (cache_htab, &fi, NO_INSERT);
166 gdb_assert (cache != NULL);
170 /* Number of virtual frames between THIS_FRAME and CACHE->NEXT_BOTTOM_FRAME.
171 If THIS_FRAME is CACHE-> NEXT_BOTTOM_FRAME return -1. */
174 existing_next_levels (struct frame_info *this_frame,
175 struct tailcall_cache *cache)
177 int retval = (frame_relative_level (this_frame)
178 - frame_relative_level (cache->next_bottom_frame) - 1);
180 gdb_assert (retval >= -1);
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
190 pretended_chain_levels (struct call_site_chain *chain)
194 gdb_assert (chain != NULL);
196 if (chain->callers == chain->length && chain->callees == chain->length)
197 return chain->length;
199 chain_levels = chain->callers + chain->callees;
200 gdb_assert (chain_levels < chain->length);
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.
208 Specific virtual tail call frames are tracked by INLINE_DEPTH. */
211 tailcall_frame_this_id (struct frame_info *this_frame, void **this_cache,
212 struct frame_id *this_id)
214 struct tailcall_cache *cache = *this_cache;
215 struct frame_info *next_frame;
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);
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);
229 /* Find PC to be unwound from THIS_FRAME. THIS_FRAME must be a part of
233 pretend_pc (struct frame_info *this_frame, struct tailcall_cache *cache)
235 int next_levels = existing_next_levels (this_frame, cache);
236 struct call_site_chain *chain = cache->chain;
238 gdb_assert (chain != NULL);
241 gdb_assert (next_levels >= 0);
243 if (next_levels < chain->callees)
244 return chain->call_site[chain->length - next_levels - 1]->pc;
245 next_levels -= chain->callees;
247 /* Otherwise CHAIN->CALLEES are already covered by CHAIN->CALLERS. */
248 if (chain->callees != chain->length)
250 if (next_levels < chain->callers)
251 return chain->call_site[chain->callers - next_levels - 1]->pc;
252 next_levels -= chain->callers;
255 gdb_assert (next_levels == 0);
256 return cache->prev_pc;
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. */
265 dwarf2_tailcall_prev_register_first (struct frame_info *this_frame,
266 void **tailcall_cachep, int regnum)
268 struct gdbarch *this_gdbarch = get_frame_arch (this_frame);
269 struct tailcall_cache *cache = *tailcall_cachep;
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))
276 int next_levels = existing_next_levels (this_frame, cache);
278 if (next_levels == cache->chain_levels - 1)
279 addr = cache->prev_sp;
281 addr = dwarf2_frame_cfa (this_frame) - cache->entry_cfa_sp_offset;
286 return frame_unwind_got_address (this_frame, regnum, addr);
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. */
294 static struct value *
295 tailcall_frame_prev_register (struct frame_info *this_frame,
296 void **this_cache, int regnum)
298 struct tailcall_cache *cache = *this_cache;
301 gdb_assert (this_frame != cache->next_bottom_frame);
303 val = dwarf2_tailcall_prev_register_first (this_frame, this_cache, regnum);
307 return frame_unwind_got_register (this_frame, regnum, regnum);
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. */
316 tailcall_frame_sniffer (const struct frame_unwind *self,
317 struct frame_info *this_frame, void **this_cache)
319 struct frame_info *next_frame;
321 struct tailcall_cache *cache;
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)
328 cache = cache_find (next_frame);
334 next_levels = existing_next_levels (this_frame, cache);
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);
340 if (next_levels == cache->chain_levels)
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.
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. */
361 dwarf2_tailcall_sniffer_first (struct frame_info *this_frame,
362 void **tailcall_cachep,
363 const LONGEST *entry_cfa_sp_offsetp)
365 CORE_ADDR prev_pc = 0, prev_sp = 0; /* GCC warning. */
368 struct gdbarch *prev_gdbarch;
369 struct call_site_chain *chain = NULL;
370 struct tailcall_cache *cache;
372 gdb_assert (*tailcall_cachep == NULL);
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);
378 /* Catch any unwinding errors. */
383 prev_gdbarch = frame_unwind_arch (this_frame);
385 /* Simulate frame_unwind_pc without setting this_frame->prev_pc.p. */
386 prev_pc = gdbarch_unwind_pc (prev_gdbarch, this_frame);
388 /* call_site_find_chain can throw an exception. */
389 chain = call_site_find_chain (prev_gdbarch, prev_pc, this_pc);
391 if (entry_cfa_sp_offsetp == NULL)
393 sp_regnum = gdbarch_sp_regnum (prev_gdbarch);
396 prev_sp = frame_unwind_register_unsigned (this_frame, sp_regnum);
399 CATCH (except, RETURN_MASK_ERROR)
401 if (entry_values_debug)
402 exception_print (gdb_stdout, except);
407 /* Ambiguous unwind or unambiguous unwind verified as matching. */
408 if (chain == NULL || chain->length == 0)
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)
422 cache->prev_sp = prev_sp;
423 cache->entry_cfa_sp_offset = *entry_cfa_sp_offsetp;
425 gdb_assert (cache->chain_levels > 0);
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
433 tailcall_frame_dealloc_cache (struct frame_info *self, void *this_cache)
435 struct tailcall_cache *cache = this_cache;
440 /* Implementation of frame_prev_arch_ftype. We assume all the virtual tail
441 call frames have gdbarch of the bottom (callee) frame. */
443 static struct gdbarch *
444 tailcall_frame_prev_arch (struct frame_info *this_frame,
445 void **this_prologue_cache)
447 struct tailcall_cache *cache = *this_prologue_cache;
449 return get_frame_arch (cache->next_bottom_frame);
452 /* Virtual tail call frame unwinder if dwarf2_tailcall_sniffer_first finds
453 a chain to create. */
455 const struct frame_unwind dwarf2_tailcall_frame_unwind =
458 default_frame_unwind_stop_reason,
459 tailcall_frame_this_id,
460 tailcall_frame_prev_register,
462 tailcall_frame_sniffer,
463 tailcall_frame_dealloc_cache,
464 tailcall_frame_prev_arch
467 /* Provide a prototype to silence -Wmissing-prototypes. */
468 extern initialize_file_ftype _initialize_tailcall_frame;
471 _initialize_tailcall_frame (void)
473 cache_htab = htab_create_alloc (50, cache_hash, cache_eq, NULL, xcalloc,