1 /****************************************************************************
2 * *
3 * GNAT RUN-TIME COMPONENTS *
4 * *
5 * T R A C E B A C K *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 2000-2020, Free Software Foundation, Inc. *
10 * *
11 * GNAT is free software; you can redistribute it and/or modify it under *
12 * terms of the GNU General Public License as published by the Free Soft- *
13 * ware Foundation; either version 3, or (at your option) any later ver- *
14 * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
15 * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
16 * or FITNESS FOR A PARTICULAR PURPOSE. *
17 * *
18 * As a special exception under Section 7 of GPL version 3, you are granted *
19 * additional permissions described in the GCC Runtime Library Exception, *
20 * version 3.1, as published by the Free Software Foundation. *
21 * *
22 * You should have received a copy of the GNU General Public License and *
23 * a copy of the GCC Runtime Library Exception along with this program; *
24 * see the files COPYING3 and COPYING.RUNTIME respectively. If not, see *
25 * <http://www.gnu.org/licenses/>. *
26 * *
27 * GNAT was originally developed by the GNAT team at New York University. *
28 * Extensive contributions were provided by Ada Core Technologies Inc. *
29 * *
30 ****************************************************************************/
31
32 /* This file contains low level support for stack unwinding using GCC intrinsic
33 functions.
34 It has been tested on the following configurations:
35 PowerPC/AiX
36 PowerPC/Darwin
37 PowerPC/VxWorks
38 PowerPC/LynxOS-178
39 SPARC/Solaris
40 i386/GNU/Linux
41 i386/Solaris
42 i386/NT
43 i386/OS2
44 i386/LynxOS
45 Alpha/VxWorks
46 Alpha/VMS
47 */
48
49 #ifdef __cplusplus
50 extern "C" {
51 #endif
52
53 #ifdef IN_RTS
54 #define POSIX
55 #include "runtime.h"
56 #include <stddef.h>
57 #else
58 #include "config.h"
59 #include "system.h"
60 /* We don't want fancy_abort here. */
61 #undef abort
62 #endif
63
64 extern int __gnat_backtrace (void **, int, void *, void *, int);
65
66 /* The point is to provide an implementation of the __gnat_backtrace function
67 above, called by the default implementation of the System.Traceback package.
68
69 We first have a series of target specific implementations, each included
70 from a separate C file for readability purposes.
71
72 Then come two flavors of a generic implementation: one relying on static
73 assumptions about the frame layout, and the other one using the GCC EH
74 infrastructure. The former uses a whole set of macros and structures which
75 may be tailored on a per target basis, and is activated as soon as
76 USE_GENERIC_UNWINDER is defined. The latter uses a small subset of the
77 macro definitions and is activated when USE_GCC_UNWINDER is defined. It is
78 only available post GCC 3.3.
79
80 Finally, there is a default dummy implementation, necessary to make the
81 linker happy on platforms where the feature is not supported, but where the
82 function is still referenced by the default System.Traceback. */
83
84 #define Lock_Task system__soft_links__lock_task
85 extern void (*Lock_Task) (void);
86
87 #define Unlock_Task system__soft_links__unlock_task
88 extern void (*Unlock_Task) (void);
89
90 /*-------------------------------------*
91 *-- Target specific implementations --*
92 *-------------------------------------*/
93
94 #if defined (_WIN64) && defined (__SEH__)
95
96 #include <windows.h>
97
98 #define IS_BAD_PTR(ptr) (IsBadCodePtr((FARPROC)ptr))
99
100 int
__gnat_backtrace(void ** array,int size,void * exclude_min,void * exclude_max,int skip_frames)101 __gnat_backtrace (void **array,
102 int size,
103 void *exclude_min,
104 void *exclude_max,
105 int skip_frames)
106 {
107 CONTEXT context;
108 UNWIND_HISTORY_TABLE history;
109 int i;
110
111 /* Get the context. */
112 RtlCaptureContext (&context);
113
114 /* Setup unwind history table (a cached to speed-up unwinding). */
115 memset (&history, 0, sizeof (history));
116
117 i = 0;
118 while (1)
119 {
120 PRUNTIME_FUNCTION RuntimeFunction;
121 KNONVOLATILE_CONTEXT_POINTERS NvContext;
122 ULONG64 ImageBase;
123 VOID *HandlerData;
124 ULONG64 EstablisherFrame;
125
126 /* Get function metadata. */
127 RuntimeFunction = RtlLookupFunctionEntry
128 (context.Rip, &ImageBase, &history);
129
130 if (!RuntimeFunction)
131 {
132 /* In case of failure, assume this is a leaf function. */
133 context.Rip = *(ULONG64 *) context.Rsp;
134 context.Rsp += 8;
135 }
136 else
137 {
138 /* If the last unwinding step failed somehow, stop here. */
139 if (IS_BAD_PTR(context.Rip))
140 break;
141
142 /* Unwind. */
143 memset (&NvContext, 0, sizeof (KNONVOLATILE_CONTEXT_POINTERS));
144 RtlVirtualUnwind (0, ImageBase, context.Rip, RuntimeFunction,
145 &context, &HandlerData, &EstablisherFrame,
146 &NvContext);
147 }
148
149 /* 0 means bottom of the stack. */
150 if (context.Rip == 0)
151 break;
152
153 /* Skip frames. */
154 if (skip_frames > 1)
155 {
156 skip_frames--;
157 continue;
158 }
159 /* Excluded frames. */
160 if ((void *)context.Rip >= exclude_min
161 && (void *)context.Rip <= exclude_max)
162 continue;
163
164 array[i++] = (void *)(context.Rip - 2);
165 if (i >= size)
166 break;
167 }
168 return i;
169 }
170 #else
171
172 /* No target specific implementation. */
173
174 /*----------------------------------------------------------------*
175 *-- Target specific definitions for the generic implementation --*
176 *----------------------------------------------------------------*/
177
178 /* The stack layout is specified by the target ABI. The "generic" scheme is
179 based on the following assumption:
180
181 The stack layout from some frame pointer is such that the information
182 required to compute the backtrace is available at static offsets.
183
184 For a given frame, the information we are interested in is the saved return
185 address (somewhere after the call instruction in the caller) and a pointer
186 to the caller's frame. The former is the base of the call chain information
187 we store in the tracebacks array. The latter allows us to loop over the
188 successive frames in the chain.
189
190 To initiate the process, we retrieve an initial frame address using the
191 appropriate GCC builtin (__builtin_frame_address).
192
193 This scheme is unfortunately not applicable on every target because the
194 stack layout is not necessarily regular (static) enough. On targets where
195 this scheme applies, the implementation relies on the following items:
196
197 o struct layout, describing the expected stack data layout relevant to the
198 information we are interested in,
199
200 o FRAME_OFFSET, the offset, from a given frame address or frame pointer
201 value, at which this layout will be found,
202
203 o FRAME_LEVEL, controls how many frames up we get at to start with,
204 from the initial frame pointer we compute by way of the GCC builtin,
205
206 0 is most often the appropriate value. 1 may be necessary on targets
207 where return addresses are saved by a function in it's caller's frame
208 (e.g. PPC).
209
210 o PC_ADJUST, to account for the difference between a call point (address
211 of a call instruction), which is what we want in the output array, and
212 the associated return address, which is what we retrieve from the stack.
213
214 o STOP_FRAME, to decide whether we reached the top of the call chain, and
215 thus if the process shall stop.
216
217 :
218 : stack
219 | +----------------+
220 | +-------->| : |
221 | | | (FRAME_OFFSET) |
222 | | | : | (PC_ADJUST)
223 | | layout:| return_address ----------------+
224 | | | .... | |
225 +--------------- next_frame | |
226 | | .... | |
227 | | | |
228 | +----------------+ | +-----+
229 | | : |<- Base fp | | : |
230 | | (FRAME_OFFSET) | (FRAME_LEVEL) | | : |
231 | | : | +---> | [1]
232 | layout:| return_address --------------------> | [0]
233 | | ... | (PC_ADJUST) +-----+
234 +---------- next_frame | traceback[]
235 | ... |
236 | |
237 +----------------+
238
239 o BASE_SKIP,
240
241 Since we inherently deal with return addresses, there is an implicit shift
242 by at least one for the initial point we are able to observe in the chain.
243
244 On some targets (e.g. sparc-solaris), the first return address we can
245 easily get without special code is even our caller's return address, so
246 there is a initial shift of two.
247
248 BASE_SKIP represents this initial shift, which is the minimal "skip_frames"
249 value we support. We could add special code for the skip_frames < BASE_SKIP
250 cases. This is not done currently because there is virtually no situation
251 in which this would be useful.
252
253 Finally, to account for some ABI specificities, a target may (but does
254 not have to) define:
255
256 o FORCE_CALL, to force a call to a dummy function at the very beginning
257 of the computation. See the PPC AIX target for an example where this
258 is useful.
259
260 o FETCH_UP_FRAME, to force an invocation of __builtin_frame_address with a
261 positive argument right after a possibly forced call even if FRAME_LEVEL
262 is 0. See the SPARC Solaris case for an example where this is useful.
263
264 */
265
266 /*------------------- Darwin 8 (OSX 10.4) or newer ----------------------*/
267 #if defined (__APPLE__) \
268 && defined (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) \
269 && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1040
270
271 #define USE_GCC_UNWINDER
272
273 #if defined (__i386__) || defined (__x86_64__)
274 #define PC_ADJUST -2
275 #elif defined (__ppc__) || defined (__ppc64__)
276 #define PC_ADJUST -4
277 #elif defined (__arm__)
278 #define PC_ADJUST -2
279 #elif defined (__arm64__)
280 #define PC_ADJUST -4
281 #else
282 #error Unhandled darwin architecture.
283 #endif
284
285 /*---------------------------- x86 *BSD --------------------------------*/
286
287 #elif defined (__i386__) && \
288 ( defined (__NetBSD__) || defined (__FreeBSD__) || defined (__OpenBSD__) )
289
290 #define USE_GCC_UNWINDER
291 /* The generic unwinder is not used for this target because the default
292 implementation doesn't unwind on the BSD platforms. AMD64 targets use the
293 gcc unwinder for all platforms, so let's keep i386 consistent with that.
294 */
295
296 #define PC_ADJUST -2
297 /* The minimum size of call instructions on this architecture is 2 bytes */
298
299 /*---------------------- ARM VxWorks ------------------------------------*/
300 #elif (defined (ARMEL) && defined (__vxworks))
301
302 #include "vxWorks.h"
303 #include "version.h"
304
305 #define USE_GCC_UNWINDER
306 #define PC_ADJUST -2
307
308 #if ((_WRS_VXWORKS_MAJOR >= 7) && (_VX_CPU != ARMARCH8A))
309 #define USING_ARM_UNWINDING 1
310 #endif
311
312 /*---------------------- ARM Linux ------------------------------------ -*/
313 #elif (defined (__ARMEL__) && defined (__linux))
314
315 #define USE_GCC_UNWINDER
316 #define PC_ADJUST -2
317 #define USING_ARM_UNWINDING 1
318
319 /*---------------------- PPC AIX/PPC Lynx 178/Older Darwin --------------*/
320 #elif ((defined (_POWER) && defined (_AIX)) || \
321 (defined (__powerpc__) && defined (__Lynx__) && !defined(__ELF__)) || \
322 (defined (__ppc__) && defined (__APPLE__)))
323
324 #define USE_GENERIC_UNWINDER
325
326 struct layout
327 {
328 struct layout *next;
329 void *pad;
330 void *return_address;
331 };
332
333 #define FRAME_OFFSET(FP) 0
334 #define PC_ADJUST -4
335
336 /* Eventhough the base PPC ABI states that a toplevel frame entry
337 should to feature a null backchain, AIX might expose a null return
338 address instead. */
339
340 /* Then LynxOS-178 features yet another variation, with return_address
341 == &<entrypoint>, with two possible entry points (one for the main
342 process and one for threads). Beware that &bla returns the address
343 of a descriptor when "bla" is a function. Getting the code address
344 requires an extra dereference. */
345
346 #if defined (__Lynx__)
347 extern void __start(); /* process entry point. */
348 extern void __runnit(); /* thread entry point. */
349 #define EXTRA_STOP_CONDITION(CURRENT) \
350 ((CURRENT)->return_address == *(void**)&__start \
351 || (CURRENT)->return_address == *(void**)&__runnit)
352 #else
353 #define EXTRA_STOP_CONDITION(CURRENT) (0)
354 #endif
355
356 #define STOP_FRAME(CURRENT, TOP_STACK) \
357 (((void *) (CURRENT) < (TOP_STACK)) \
358 || (CURRENT)->return_address == NULL \
359 || EXTRA_STOP_CONDITION(CURRENT))
360
361 /* The PPC ABI has an interesting specificity: the return address saved by a
362 function is located in it's caller's frame, and the save operation only
363 takes place if the function performs a call.
364
365 To have __gnat_backtrace retrieve its own return address, we then
366 define ... */
367
368 #define FORCE_CALL 1
369 #define FRAME_LEVEL 1
370
371 #define BASE_SKIP 1
372
373 /*----------- PPC ELF (GNU/Linux & VxWorks & Lynx178e) -------------------*/
374
375 #elif (defined (_ARCH_PPC) && defined (__vxworks)) || \
376 (defined (__powerpc__) && defined (__Lynx__) && defined(__ELF__)) || \
377 (defined (__linux__) && defined (__powerpc__))
378
379 #if defined (_ARCH_PPC64) && !defined (__USING_SJLJ_EXCEPTIONS__)
380 #define USE_GCC_UNWINDER
381 #else
382 #define USE_GENERIC_UNWINDER
383 #endif
384
385 struct layout
386 {
387 struct layout *next;
388 void *return_address;
389 };
390
391 #define FORCE_CALL 1
392 #define FRAME_LEVEL 1
393 /* See the PPC AIX case for an explanation of these values. */
394
395 #define FRAME_OFFSET(FP) 0
396 #define PC_ADJUST -4
397
398 /* According to the base PPC ABI, a toplevel frame entry should feature
399 a null backchain. What happens at signal handler frontiers isn't so
400 well specified, so we add a safety guard on top. */
401
402 #define STOP_FRAME(CURRENT, TOP_STACK) \
403 ((CURRENT)->next == 0 || ((long)(CURRENT)->next % __alignof__(void*)) != 0)
404
405 #define BASE_SKIP 1
406
407 /*-------------------------- SPARC Solaris -----------------------------*/
408
409 #elif defined (__sun__) && defined (__sparc__)
410
411 #define USE_GENERIC_UNWINDER
412
413 /* These definitions are inspired from the Appendix D (Software
414 Considerations) of the SPARC V8 architecture manual. */
415
416 struct layout
417 {
418 struct layout *next;
419 void *return_address;
420 };
421
422 #ifdef __arch64__
423 #define STACK_BIAS 2047 /* V9 ABI */
424 #else
425 #define STACK_BIAS 0 /* V8 ABI */
426 #endif
427
428 #define FRAME_LEVEL 0
429 #define FRAME_OFFSET(FP) (14 * sizeof (void*) + (FP ? STACK_BIAS : 0))
430 #define PC_ADJUST 0
431 #define STOP_FRAME(CURRENT, TOP_STACK) \
432 ((CURRENT)->return_address == 0|| (CURRENT)->next == 0 \
433 || (void *) (CURRENT) < (TOP_STACK))
434
435 /* The SPARC register windows need to be flushed before we may access them
436 from the stack. This is achieved by way of builtin_frame_address only
437 when the "count" argument is positive, so force at least one such call. */
438 #define FETCH_UP_FRAME_ADDRESS
439
440 #define BASE_SKIP 2
441 /* From the frame pointer of frame N, we are accessing the flushed register
442 window of frame N-1 (positive offset from fp), in which we retrieve the
443 saved return address. We then end up with our caller's return address. */
444
445 /*---------------------------- x86 & x86_64 ---------------------------------*/
446
447 #elif defined (__i386__) || defined (__x86_64__)
448
449 #if defined (__WIN32)
450 #include <windows.h>
451 #define IS_BAD_PTR(ptr) (IsBadCodePtr((FARPROC)ptr))
452 #elif defined (__sun__)
453 #define IS_BAD_PTR(ptr) ((unsigned long)ptr == -1UL)
454 #else
455 #define IS_BAD_PTR(ptr) 0
456 #endif
457
458 /* Use the dwarf2 unwinder when we expect to have dwarf2 tables at
459 hand. Backtraces will reliably stop on frames missing such tables,
460 but our only alternative is the generic unwinder which requires
461 compilation forcing a frame pointer to be reliable. */
462
463 #if (defined (__x86_64__) || defined (__linux__)) && !defined (__USING_SJLJ_EXCEPTIONS__)
464 #define USE_GCC_UNWINDER
465 #else
466 #define USE_GENERIC_UNWINDER
467 #endif
468
469 struct layout
470 {
471 struct layout *next;
472 void *return_address;
473 };
474
475 #define FRAME_LEVEL 1
476 /* builtin_frame_address (1) is expected to work on this family of targets,
477 and (0) might return the soft stack pointer, which does not designate a
478 location where a backchain and a return address might be found. */
479
480 #define FRAME_OFFSET(FP) 0
481 #define PC_ADJUST -2
482 #define STOP_FRAME(CURRENT, TOP_STACK) \
483 (IS_BAD_PTR((long)(CURRENT)) \
484 || (void *) (CURRENT) < (TOP_STACK) \
485 || IS_BAD_PTR((long)(CURRENT)->return_address) \
486 || (CURRENT)->return_address == 0 \
487 || (void *) ((CURRENT)->next) < (TOP_STACK) \
488 || EXTRA_STOP_CONDITION(CURRENT))
489
490 #define BASE_SKIP (1+FRAME_LEVEL)
491
492 /* On i386 architecture we check that at the call point we really have a call
493 insn. Possible call instructions are:
494
495 call addr16 E8 xx xx xx xx
496 call reg FF Dx
497 call off(reg) FF xx xx
498 lcall addr seg 9A xx xx xx xx xx xx
499
500 This check will not catch all cases but it will increase the backtrace
501 reliability on this architecture.
502 */
503
504 #define VALID_STACK_FRAME(ptr) \
505 (!IS_BAD_PTR(ptr) \
506 && (((*((ptr) - 3) & 0xff) == 0xe8) \
507 || ((*((ptr) - 5) & 0xff) == 0x9a) \
508 || ((*((ptr) - 1) & 0xff) == 0xff) \
509 || (((*(ptr) & 0xd0ff) == 0xd0ff))))
510
511 #if defined (__vxworks) && defined (__RTP__)
512
513 /* For VxWorks following backchains past the "main" frame gets us into the
514 kernel space, where it can't be dereferenced. So lets stop at the main
515 symbol. */
516 extern void main();
517
518 static int
is_return_from(void * symbol_addr,void * ret_addr)519 is_return_from(void *symbol_addr, void *ret_addr)
520 {
521 int ret = 0;
522 char *ptr = (char *)ret_addr;
523
524 if ((*(ptr - 5) & 0xff) == 0xe8)
525 {
526 /* call addr16 E8 xx xx xx xx */
527 int32_t offset = *(int32_t *)(ptr - 4);
528 ret = (ptr + offset) == symbol_addr;
529 }
530
531 /* Others not implemented yet... But it is very likely that call addr16
532 is used here. */
533 return ret;
534 }
535
536 #define EXTRA_STOP_CONDITION(CURRENT) \
537 (is_return_from(&main, (CURRENT)->return_address))
538 #else /* not (defined (__vxworks) && defined (__RTP__)) */
539 #define EXTRA_STOP_CONDITION(CURRENT) (0)
540 #endif /* not (defined (__vxworks) && defined (__RTP__)) */
541
542 /*----------------------------- qnx ----------------------------------*/
543
544 #elif defined (__QNX__)
545
546 #define USE_GCC_UNWINDER
547
548 #if defined (__aarch64__)
549 #define PC_ADJUST -4
550 #else
551 #error Unhandled QNX architecture.
552 #endif
553
554 /*------------------- aarch64-linux ----------------------------------*/
555
556 #elif (defined (__aarch64__) && defined (__linux__))
557
558 #define USE_GCC_UNWINDER
559 #define PC_ADJUST -4
560
561 /*----------------------------- ia64 ---------------------------------*/
562
563 #elif defined (__ia64__) && (defined (__linux__) || defined (__hpux__))
564
565 #define USE_GCC_UNWINDER
566 /* Use _Unwind_Backtrace driven exceptions on ia64 HP-UX and ia64
567 GNU/Linux, where _Unwind_Backtrace is provided by the system unwind
568 library. On HP-UX 11.23 this requires patch PHSS_33352, which adds
569 _Unwind_Backtrace to the system unwind library. */
570
571 #define PC_ADJUST -4
572
573
574 #endif
575
576 /*---------------------------------------------------------------------*
577 *-- The post GCC 3.3 infrastructure based implementation --*
578 *---------------------------------------------------------------------*/
579
580 #if defined (USE_GCC_UNWINDER) && (__GNUC__ * 10 + __GNUC_MINOR__ > 33)
581
582 /* Conditioning the inclusion on the GCC version is useful to avoid bootstrap
583 path problems, since the included file refers to post 3.3 functions in
584 libgcc, and the stage1 compiler is unlikely to be linked against a post 3.3
585 library. It actually disables the support for backtraces in this compiler
586 for targets defining USE_GCC_UNWINDER, which is OK since we don't use the
587 traceback capability in the compiler anyway.
588
589 The condition is expressed the way above because we cannot reliably rely on
590 any other macro from the base compiler when compiling stage1. */
591
592 #ifdef USING_ARM_UNWINDING
593 /* This value is not part of the enumerated reason codes defined in unwind.h
594 for ARM style unwinding, but is used in the included "C" code, so we
595 define it to a reasonable value to avoid a compilation error. */
596 #define _URC_NORMAL_STOP 0
597 #endif
598
599 /* This is an implementation of the __gnat_backtrace routine using the
600 underlying GCC unwinding support associated with the exception handling
601 infrastructure. This will only work for ZCX based applications. */
602
603 #include <unwind.h>
604
605 /* The implementation boils down to a call to _Unwind_Backtrace with a
606 tailored callback and carried-on data structure to keep track of the
607 input parameters we got as well as of the basic processing state. */
608
609 /******************
610 * trace_callback *
611 ******************/
612
613 #if !defined (__USING_SJLJ_EXCEPTIONS__)
614
615 typedef struct {
616 void ** traceback;
617 int max_len;
618 void * exclude_min;
619 void * exclude_max;
620 int n_frames_to_skip;
621 int n_frames_skipped;
622 int n_entries_filled;
623 } uw_data_t;
624
625 #if defined (__ia64__) && defined (__hpux__)
626 #include <uwx.h>
627 #endif
628
629 static _Unwind_Reason_Code
trace_callback(struct _Unwind_Context * uw_context,uw_data_t * uw_data)630 trace_callback (struct _Unwind_Context * uw_context, uw_data_t * uw_data)
631 {
632 char * pc;
633
634 #if defined (__ia64__) && defined (__hpux__) && defined (USE_LIBUNWIND_EXCEPTIONS)
635 /* Work around problem with _Unwind_GetIP on ia64 HP-UX. */
636 uwx_get_reg ((struct uwx_env *) uw_context, UWX_REG_IP, (uint64_t *) &pc);
637 #else
638 pc = (char *) _Unwind_GetIP (uw_context);
639 #endif
640
641 if (uw_data->n_frames_skipped < uw_data->n_frames_to_skip)
642 {
643 uw_data->n_frames_skipped ++;
644 return _URC_NO_REASON;
645 }
646
647 if (uw_data->n_entries_filled >= uw_data->max_len)
648 return _URC_NORMAL_STOP;
649
650 if (pc < (char *)uw_data->exclude_min || pc > (char *)uw_data->exclude_max)
651 uw_data->traceback [uw_data->n_entries_filled ++] = pc + PC_ADJUST;
652
653 return _URC_NO_REASON;
654 }
655
656 #endif
657
658 /********************
659 * __gnat_backtrace *
660 ********************/
661
662 int
__gnat_backtrace(void ** traceback,int max_len,void * exclude_min,void * exclude_max,int skip_frames)663 __gnat_backtrace (void ** traceback __attribute__((unused)),
664 int max_len __attribute__((unused)),
665 void * exclude_min __attribute__((unused)),
666 void * exclude_max __attribute__((unused)),
667 int skip_frames __attribute__((unused)))
668 {
669 #if defined (__USING_SJLJ_EXCEPTIONS__)
670 /* We have no unwind material (tables) at hand with sjlj eh, and no
671 way to retrieve complete and accurate call chain information from
672 the context stack we maintain. */
673 return 0;
674 #else
675 uw_data_t uw_data;
676 /* State carried over during the whole unwinding process. */
677
678 uw_data.traceback = traceback;
679 uw_data.max_len = max_len;
680 uw_data.exclude_min = exclude_min;
681 uw_data.exclude_max = exclude_max;
682
683 uw_data.n_frames_to_skip = skip_frames;
684
685 uw_data.n_frames_skipped = 0;
686 uw_data.n_entries_filled = 0;
687
688 _Unwind_Backtrace ((_Unwind_Trace_Fn)trace_callback, &uw_data);
689
690 return uw_data.n_entries_filled;
691 #endif
692 }
693
694 /*------------------------------------------------------------------*
695 *-- The generic implementation based on frame layout assumptions --*
696 *------------------------------------------------------------------*/
697
698 #elif defined (USE_GENERIC_UNWINDER)
699
700 /* No warning since the cases where FRAME_LEVEL > 0 are known to work. */
701 #pragma GCC diagnostic ignored "-Wframe-address"
702
703 #ifndef CURRENT_STACK_FRAME
704 # define CURRENT_STACK_FRAME ({ char __csf; &__csf; })
705 #endif
706
707 #ifndef VALID_STACK_FRAME
708 #define VALID_STACK_FRAME(ptr) 1
709 #endif
710
711 #ifndef MAX
712 #define MAX(x,y) ((x) > (y) ? (x) : (y))
713 #endif
714
715 #ifndef FORCE_CALL
716 #define FORCE_CALL 0
717 #endif
718
719 /* Make sure the function is not inlined. */
720 static void forced_callee (void) __attribute__ ((noinline));
721
forced_callee(void)722 static void forced_callee (void)
723 {
724 /* Make sure the function is not pure. */
725 volatile int i __attribute__ ((unused)) = 0;
726 }
727
728 int
__gnat_backtrace(void ** array,int size,void * exclude_min,void * exclude_max,int skip_frames)729 __gnat_backtrace (void **array,
730 int size,
731 void *exclude_min,
732 void *exclude_max,
733 int skip_frames)
734 {
735 struct layout *current;
736 void *top_frame;
737 void *top_stack ATTRIBUTE_UNUSED;
738 int cnt = 0;
739
740 if (FORCE_CALL)
741 forced_callee ();
742
743 /* Force a call to builtin_frame_address with a positive argument
744 if required. This is necessary e.g. on SPARC to have the register
745 windows flushed before we attempt to access them on the stack. */
746 #if defined (FETCH_UP_FRAME_ADDRESS) && (FRAME_LEVEL == 0)
747 __builtin_frame_address (1);
748 #endif
749
750 top_frame = __builtin_frame_address (FRAME_LEVEL);
751 top_stack = CURRENT_STACK_FRAME;
752 current = (struct layout *) ((size_t) top_frame + FRAME_OFFSET (0));
753
754 /* Skip the number of calls we have been requested to skip, accounting for
755 the BASE_SKIP parameter.
756
757 FRAME_LEVEL is meaningless for the count adjustment. It impacts where we
758 start retrieving data from, but how many frames "up" we start at is in
759 BASE_SKIP by definition. */
760
761 skip_frames = MAX (0, skip_frames - BASE_SKIP);
762
763 while (cnt < skip_frames)
764 {
765 current = (struct layout *) ((size_t) current->next + FRAME_OFFSET (1));
766 cnt++;
767 }
768
769 cnt = 0;
770 while (cnt < size)
771 {
772 if (STOP_FRAME (current, top_stack) ||
773 !VALID_STACK_FRAME(((char *) current->return_address) + PC_ADJUST))
774 break;
775
776 if (current->return_address < exclude_min
777 || current->return_address > exclude_max)
778 array[cnt++] = ((char *) current->return_address) + PC_ADJUST;
779
780 current = (struct layout *) ((size_t) current->next + FRAME_OFFSET (1));
781 }
782
783 return cnt;
784 }
785
786 #else
787
788 /* No target specific implementation and neither USE_GCC_UNWINDER nor
789 USE_GENERIC_UNWINDER defined. */
790
791 /*------------------------------*
792 *-- The dummy implementation --*
793 *------------------------------*/
794
795 int
__gnat_backtrace(void ** array ATTRIBUTE_UNUSED,int size ATTRIBUTE_UNUSED,void * exclude_min ATTRIBUTE_UNUSED,void * exclude_max ATTRIBUTE_UNUSED,int skip_frames ATTRIBUTE_UNUSED)796 __gnat_backtrace (void **array ATTRIBUTE_UNUSED,
797 int size ATTRIBUTE_UNUSED,
798 void *exclude_min ATTRIBUTE_UNUSED,
799 void *exclude_max ATTRIBUTE_UNUSED,
800 int skip_frames ATTRIBUTE_UNUSED)
801 {
802 return 0;
803 }
804
805 #endif
806
807 #endif
808
809 #ifdef __cplusplus
810 }
811 #endif
812