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