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