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