f112b4ecca48e297fa0e078a429b0aa9a4c549cb
[deliverable/binutils-gdb.git] / gdb / dwarf2 / frame-tailcall.c
1 /* Virtual tail call frames unwinder for GDB.
2
3 Copyright (C) 2010-2021 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 "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. */
34 static 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. */
39 struct tailcall_cache
40 {
41 /* It must be the first one of this struct. It is the furthest callee. */
42 struct frame_info *next_bottom_frame;
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. */
49 struct call_site_chain *chain;
50
51 /* Cached pretended_chain_levels result. */
52 int chain_levels;
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;
64 LONGEST entry_cfa_sp_offset;
65 };
66
67 /* hash_f for htab_create_alloc of cache_htab. */
68
69 static hashval_t
70 cache_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
79 static int
80 cache_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
92 static struct tailcall_cache *
93 cache_new_ref1 (struct frame_info *next_bottom_frame)
94 {
95 struct tailcall_cache *cache = XCNEW (struct tailcall_cache);
96 void **slot;
97
98 cache->next_bottom_frame = next_bottom_frame;
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
110 static void
111 cache_ref (struct tailcall_cache *cache)
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
121 static void
122 cache_unref (struct tailcall_cache *cache)
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
139 static int
140 frame_is_tailcall (struct frame_info *fi)
141 {
142 return frame_unwinder_is (fi, &dwarf2_tailcall_frame_unwind);
143 }
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
148 static struct tailcall_cache *
149 cache_find (struct frame_info *fi)
150 {
151 struct tailcall_cache *cache;
152 void **slot;
153
154 while (frame_is_tailcall (fi))
155 {
156 fi = get_next_frame (fi);
157 gdb_assert (fi != NULL);
158 }
159
160 slot = htab_find_slot (cache_htab, &fi, NO_INSERT);
161 if (slot == NULL)
162 return NULL;
163
164 cache = (struct tailcall_cache *) *slot;
165 gdb_assert (cache != NULL);
166 return cache;
167 }
168
169 /* Number of virtual frames between THIS_FRAME and CACHE->NEXT_BOTTOM_FRAME.
170 If THIS_FRAME is CACHE-> NEXT_BOTTOM_FRAME return -1. */
171
172 static int
173 existing_next_levels (struct frame_info *this_frame,
174 struct tailcall_cache *cache)
175 {
176 int retval = (frame_relative_level (this_frame)
177 - frame_relative_level (cache->next_bottom_frame) - 1);
178
179 gdb_assert (retval >= -1);
180
181 return retval;
182 }
183
184 /* The number of virtual tail call frames in CHAIN. With no virtual tail call
185 frames the function would return 0 (but CHAIN does not exist in such
186 case). */
187
188 static int
189 pretended_chain_levels (struct call_site_chain *chain)
190 {
191 int chain_levels;
192
193 gdb_assert (chain != NULL);
194
195 if (chain->callers == chain->length && chain->callees == chain->length)
196 return chain->length;
197
198 chain_levels = chain->callers + chain->callees;
199 gdb_assert (chain_levels <= chain->length);
200
201 return chain_levels;
202 }
203
204 /* Implementation of frame_this_id_ftype. THIS_CACHE must be already
205 initialized with tailcall_cache, THIS_FRAME must be a part of THIS_CACHE.
206
207 Specific virtual tail call frames are tracked by INLINE_DEPTH. */
208
209 static void
210 tailcall_frame_this_id (struct frame_info *this_frame, void **this_cache,
211 struct frame_id *this_id)
212 {
213 struct tailcall_cache *cache = (struct tailcall_cache *) *this_cache;
214 struct frame_info *next_frame;
215
216 /* Tail call does not make sense for a sentinel frame. */
217 next_frame = get_next_frame (this_frame);
218 gdb_assert (next_frame != NULL);
219
220 *this_id = get_frame_id (next_frame);
221 (*this_id).code_addr = get_frame_pc (this_frame);
222 (*this_id).code_addr_p = true;
223 (*this_id).artificial_depth = (cache->chain_levels
224 - existing_next_levels (this_frame, cache));
225 gdb_assert ((*this_id).artificial_depth > 0);
226 }
227
228 /* Find PC to be unwound from THIS_FRAME. THIS_FRAME must be a part of
229 CACHE. */
230
231 static CORE_ADDR
232 pretend_pc (struct frame_info *this_frame, struct tailcall_cache *cache)
233 {
234 int next_levels = existing_next_levels (this_frame, cache);
235 struct call_site_chain *chain = cache->chain;
236
237 gdb_assert (chain != NULL);
238
239 next_levels++;
240 gdb_assert (next_levels >= 0);
241
242 if (next_levels < chain->callees)
243 return chain->call_site[chain->length - next_levels - 1]->pc;
244 next_levels -= chain->callees;
245
246 /* Otherwise CHAIN->CALLEES are already covered by CHAIN->CALLERS. */
247 if (chain->callees != chain->length)
248 {
249 if (next_levels < chain->callers)
250 return chain->call_site[chain->callers - next_levels - 1]->pc;
251 next_levels -= chain->callers;
252 }
253
254 gdb_assert (next_levels == 0);
255 return cache->prev_pc;
256 }
257
258 /* Implementation of frame_prev_register_ftype. If no specific register
259 override is supplied NULL is returned (this is incompatible with
260 frame_prev_register_ftype semantics). next_bottom_frame and tail call
261 frames unwind the NULL case differently. */
262
263 struct value *
264 dwarf2_tailcall_prev_register_first (struct frame_info *this_frame,
265 void **tailcall_cachep, int regnum)
266 {
267 struct gdbarch *this_gdbarch = get_frame_arch (this_frame);
268 struct tailcall_cache *cache = (struct tailcall_cache *) *tailcall_cachep;
269 CORE_ADDR addr;
270
271 if (regnum == gdbarch_pc_regnum (this_gdbarch))
272 addr = pretend_pc (this_frame, cache);
273 else if (cache->prev_sp_p && regnum == gdbarch_sp_regnum (this_gdbarch))
274 {
275 int next_levels = existing_next_levels (this_frame, cache);
276
277 if (next_levels == cache->chain_levels - 1)
278 addr = cache->prev_sp;
279 else
280 addr = dwarf2_frame_cfa (this_frame) - cache->entry_cfa_sp_offset;
281 }
282 else
283 return NULL;
284
285 return frame_unwind_got_address (this_frame, regnum, addr);
286 }
287
288 /* Implementation of frame_prev_register_ftype for tail call frames. Register
289 set of virtual tail call frames is assumed to be the one of the top (caller)
290 frame - assume unchanged register value for NULL from
291 dwarf2_tailcall_prev_register_first. */
292
293 static struct value *
294 tailcall_frame_prev_register (struct frame_info *this_frame,
295 void **this_cache, int regnum)
296 {
297 struct tailcall_cache *cache = (struct tailcall_cache *) *this_cache;
298 struct value *val;
299
300 gdb_assert (this_frame != cache->next_bottom_frame);
301
302 val = dwarf2_tailcall_prev_register_first (this_frame, this_cache, regnum);
303 if (val)
304 return val;
305
306 return frame_unwind_got_register (this_frame, regnum, regnum);
307 }
308
309 /* Implementation of frame_sniffer_ftype. It will never find a new chain, use
310 dwarf2_tailcall_sniffer_first for the bottom (callee) frame. It will find
311 all the predecessing virtual tail call frames, it will return false when
312 there exist no more tail call frames in this chain. */
313
314 static int
315 tailcall_frame_sniffer (const struct frame_unwind *self,
316 struct frame_info *this_frame, void **this_cache)
317 {
318 struct frame_info *next_frame;
319 int next_levels;
320 struct tailcall_cache *cache;
321
322 if (!dwarf2_frame_unwinders_enabled_p)
323 return 0;
324
325 /* Inner tail call element does not make sense for a sentinel frame. */
326 next_frame = get_next_frame (this_frame);
327 if (next_frame == NULL)
328 return 0;
329
330 cache = cache_find (next_frame);
331 if (cache == NULL)
332 return 0;
333
334 cache_ref (cache);
335
336 next_levels = existing_next_levels (this_frame, cache);
337
338 /* NEXT_LEVELS is -1 only in dwarf2_tailcall_sniffer_first. */
339 gdb_assert (next_levels >= 0);
340 gdb_assert (next_levels <= cache->chain_levels);
341
342 if (next_levels == cache->chain_levels)
343 {
344 cache_unref (cache);
345 return 0;
346 }
347
348 *this_cache = cache;
349 return 1;
350 }
351
352 /* The initial "sniffer" whether THIS_FRAME is a bottom (callee) frame of a new
353 chain to create. Keep TAILCALL_CACHEP NULL if it did not find any chain,
354 initialize it otherwise. No tail call chain is created if there are no
355 unambiguous virtual tail call frames to report.
356
357 ENTRY_CFA_SP_OFFSETP is NULL if no special SP handling is possible,
358 otherwise *ENTRY_CFA_SP_OFFSETP is the number of bytes to subtract from tail
359 call frames frame base to get the SP value there - to simulate return
360 address pushed on the stack. */
361
362 void
363 dwarf2_tailcall_sniffer_first (struct frame_info *this_frame,
364 void **tailcall_cachep,
365 const LONGEST *entry_cfa_sp_offsetp)
366 {
367 CORE_ADDR prev_pc = 0, prev_sp = 0; /* GCC warning. */
368 int prev_sp_p = 0;
369 CORE_ADDR this_pc;
370 struct gdbarch *prev_gdbarch;
371 gdb::unique_xmalloc_ptr<call_site_chain> chain;
372 struct tailcall_cache *cache;
373
374 gdb_assert (*tailcall_cachep == NULL);
375
376 /* PC may be after the function if THIS_FRAME calls noreturn function,
377 get_frame_address_in_block will decrease it by 1 in such case. */
378 this_pc = get_frame_address_in_block (this_frame);
379
380 try
381 {
382 int sp_regnum;
383
384 prev_gdbarch = frame_unwind_arch (this_frame);
385
386 /* Simulate frame_unwind_pc without setting this_frame->prev_pc.p. */
387 prev_pc = gdbarch_unwind_pc (prev_gdbarch, this_frame);
388
389 /* call_site_find_chain can throw an exception. */
390 chain = call_site_find_chain (prev_gdbarch, prev_pc, this_pc);
391
392 if (entry_cfa_sp_offsetp != NULL)
393 {
394 sp_regnum = gdbarch_sp_regnum (prev_gdbarch);
395 if (sp_regnum != -1)
396 {
397 prev_sp = frame_unwind_register_unsigned (this_frame, sp_regnum);
398 prev_sp_p = 1;
399 }
400 }
401 }
402 catch (const gdb_exception_error &except)
403 {
404 if (entry_values_debug)
405 exception_print (gdb_stdout, except);
406
407 switch (except.error)
408 {
409 case NO_ENTRY_VALUE_ERROR:
410 /* Thrown by call_site_find_chain. */
411 case MEMORY_ERROR:
412 case OPTIMIZED_OUT_ERROR:
413 case NOT_AVAILABLE_ERROR:
414 /* These can normally happen when we try to access an
415 optimized out or unavailable register, either in a
416 physical register or spilled to memory. */
417 return;
418 }
419
420 /* Let unexpected errors propagate. */
421 throw;
422 }
423
424 /* Ambiguous unwind or unambiguous unwind verified as matching. */
425 if (chain == NULL || chain->length == 0)
426 return;
427
428 cache = cache_new_ref1 (this_frame);
429 *tailcall_cachep = cache;
430 cache->chain = chain.release ();
431 cache->prev_pc = prev_pc;
432 cache->chain_levels = pretended_chain_levels (cache->chain);
433 cache->prev_sp_p = prev_sp_p;
434 if (cache->prev_sp_p)
435 {
436 cache->prev_sp = prev_sp;
437 cache->entry_cfa_sp_offset = *entry_cfa_sp_offsetp;
438 }
439 gdb_assert (cache->chain_levels > 0);
440 }
441
442 /* Implementation of frame_dealloc_cache_ftype. It can be called even for the
443 bottom chain frame from dwarf2_frame_dealloc_cache which is not a real
444 TAILCALL_FRAME. */
445
446 static void
447 tailcall_frame_dealloc_cache (struct frame_info *self, void *this_cache)
448 {
449 struct tailcall_cache *cache = (struct tailcall_cache *) this_cache;
450
451 cache_unref (cache);
452 }
453
454 /* Implementation of frame_prev_arch_ftype. We assume all the virtual tail
455 call frames have gdbarch of the bottom (callee) frame. */
456
457 static struct gdbarch *
458 tailcall_frame_prev_arch (struct frame_info *this_frame,
459 void **this_prologue_cache)
460 {
461 struct tailcall_cache *cache = (struct tailcall_cache *) *this_prologue_cache;
462
463 return get_frame_arch (cache->next_bottom_frame);
464 }
465
466 /* Virtual tail call frame unwinder if dwarf2_tailcall_sniffer_first finds
467 a chain to create. */
468
469 const struct frame_unwind dwarf2_tailcall_frame_unwind =
470 {
471 "dwarf2 tailcall",
472 TAILCALL_FRAME,
473 default_frame_unwind_stop_reason,
474 tailcall_frame_this_id,
475 tailcall_frame_prev_register,
476 NULL,
477 tailcall_frame_sniffer,
478 tailcall_frame_dealloc_cache,
479 tailcall_frame_prev_arch
480 };
481
482 void _initialize_tailcall_frame ();
483 void
484 _initialize_tailcall_frame ()
485 {
486 cache_htab = htab_create_alloc (50, cache_hash, cache_eq, NULL, xcalloc,
487 xfree);
488 }
This page took 0.03832 seconds and 3 git commands to generate.