1 /****************************************************************************
3 * GNAT COMPILER COMPONENTS *
7 * C Implementation File *
9 * Copyright (C) 2000-2006, AdaCore *
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 2, 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. See the GNU General Public License *
17 * for more details. You should have received a copy of the GNU General *
18 * Public License distributed with GNAT; see file COPYING. If not, write *
19 * to the Free Software Foundation, 51 Franklin Street, Fifth Floor, *
20 * Boston, MA 02110-1301, USA. *
22 * As a special exception, if you link this file with other files to *
23 * produce an executable, this file does not by itself cause the resulting *
24 * executable to be covered by the GNU General Public License. This except- *
25 * ion does not however invalidate any other reasons why the executable *
26 * file might be covered by the GNU Public License. *
28 * GNAT was originally developed by the GNAT team at New York University. *
29 * Extensive contributions were provided by Ada Core Technologies Inc. *
31 ****************************************************************************/
33 /* This file contains low level support for stack unwinding using GCC intrinsic
35 It has been tested on the following configurations:
49 #ifdef __alpha_vxworks
62 extern int __gnat_backtrace (void **, int, void *, void *, int);
64 /* The point is to provide an implementation of the __gnat_backtrace function
65 above, called by the default implementation of the System.Traceback package.
67 We first have a series of target specific implementations, each included
68 from a separate C file for readability purposes.
70 Then come two flavors of a generic implementation: one relying on static
71 assumptions about the frame layout, and the other one using the GCC EH
72 infrastructure. The former uses a whole set of macros and structures which
73 may be tailored on a per target basis, and is activated as soon as
74 USE_GENERIC_UNWINDER is defined. The latter uses a small subset of the
75 macro definitions and is activated when USE_GCC_UNWINDER is defined. It is
76 only available post GCC 3.3.
78 Finally, there is a default dummy implementation, necessary to make the
79 linker happy on platforms where the feature is not supported, but where the
80 function is still referenced by the default System.Traceback. */
82 #define Lock_Task system__soft_links__lock_task
83 extern void (*Lock_Task) (void);
85 #define Unlock_Task system__soft_links__unlock_task
86 extern void (*Unlock_Task) (void);
88 /*-------------------------------------*
89 *-- Target specific implementations --*
90 *-------------------------------------*/
92 #if defined (__alpha_vxworks)
96 #elif defined (__ALPHA) && defined (__VMS__)
101 /* No target specific implementation. */
103 /*----------------------------------------------------------------*
104 *-- Target specific definitions for the generic implementation --*
105 *----------------------------------------------------------------*/
107 /* The stack layout is specified by the target ABI. The "generic" scheme is
108 based on the following assumption:
110 The stack layout from some frame pointer is such that the information
111 required to compute the backtrace is available at static offsets.
113 For a given frame, the information we are interested in is the saved return
114 address (somewhere after the call instruction in the caller) and a pointer
115 to the caller's frame. The former is the base of the call chain information
116 we store in the tracebacks array. The latter allows us to loop over the
117 successive frames in the chain.
119 To initiate the process, we retrieve an initial frame address using the
120 appropriate GCC builtin (__builtin_frame_address).
122 This scheme is unfortunately not applicable on every target because the
123 stack layout is not necessarily regular (static) enough. On targets where
124 this scheme applies, the implementation relies on the following items:
126 o struct layout, describing the expected stack data layout relevant to the
127 information we are interested in,
129 o FRAME_OFFSET, the offset, from a given frame address or frame pointer
130 value, at which this layout will be found,
132 o FRAME_LEVEL, controls how many frames up we get at to start with,
133 from the initial frame pointer we compute by way of the GCC builtin,
135 0 is most often the appropriate value. 1 may be necessary on targets
136 where return addresses are saved by a function in it's caller's frame
139 o PC_ADJUST, to account for the difference between a call point (address
140 of a call instruction), which is what we want in the output array, and
141 the associated return address, which is what we retrieve from the stack.
143 o STOP_FRAME, to decide wether we reached the top of the call chain, and
144 thus if the process shall stop.
150 | | | (FRAME_OFFSET) |
151 | | | : | (PC_ADJUST)
152 | | layout:| return_address ----------------+
154 +--------------- next_frame | |
157 | +----------------+ | +-----+
158 | | : |<- Base fp | | : |
159 | | (FRAME_OFFSET) | (FRAME_LEVEL) | | : |
161 | layout:| return_address --------------------> | [0]
162 | | ... | (PC_ADJUST) +-----+
163 +---------- next_frame | traceback[]
170 Since we inherently deal with return addresses, there is an implicit shift
171 by at least one for the initial point we are able to observe in the chain.
173 On some targets (e.g. sparc-solaris), the first return address we can
174 easily get without special code is even our caller's return address, so
175 there is a initial shift of two.
177 BASE_SKIP represents this initial shift, which is the minimal "skip_frames"
178 value we support. We could add special code for the skip_frames < BASE_SKIP
179 cases. This is not done currently because there is virtually no situation
180 in which this would be useful.
182 Finally, to account for some ABI specificities, a target may (but does
185 o FORCE_CALL, to force a call to a dummy function at the very beginning
186 of the computation. See the PPC AIX target for an example where this
189 o FETCH_UP_FRAME, to force an invocation of __builtin_frame_address with a
190 positive argument right after a possibly forced call even if FRAME_LEVEL
191 is 0. See the SPARC Solaris case for an example where this is useful.
195 /*--------------------------- PPC AIX/Darwin ----------------------------*/
197 #if ((defined (_POWER) && defined (_AIX)) || \
198 (defined (__ppc__) && defined (__APPLE__)))
200 #define USE_GENERIC_UNWINDER
206 void *return_address;
209 #define FRAME_OFFSET(FP) 0
211 #define STOP_FRAME(CURRENT, TOP_STACK) ((void *) (CURRENT) < (TOP_STACK))
213 /* The PPC ABI has an interesting specificity: the return address saved by a
214 function is located in it's caller's frame, and the save operation only
215 takes place if the function performs a call.
217 To have __gnat_backtrace retrieve its own return address, we then
221 #define FRAME_LEVEL 1
225 /*---------------------------- PPC VxWorks------------------------------*/
227 #elif defined (_ARCH_PPC) && defined (__vxworks)
229 #define USE_GENERIC_UNWINDER
234 void *return_address;
238 #define FRAME_LEVEL 1
239 /* See the PPC AIX case for an explanation of these values. */
241 #define FRAME_OFFSET(FP) 0
243 #define STOP_FRAME(CURRENT, TOP_STACK) ((CURRENT)->next == 0)
247 /*-------------------------- SPARC Solaris -----------------------------*/
249 #elif defined (sun) && defined (sparc)
251 #define USE_GENERIC_UNWINDER
253 /* These definitions are inspired from the Appendix D (Software
254 Considerations) of the SPARC V8 architecture manual. */
259 void *return_address;
263 #define STACK_BIAS 2047 /* V9 ABI */
265 #define STACK_BIAS 0 /* V8 ABI */
268 #define FRAME_LEVEL 0
269 #define FRAME_OFFSET(FP) (14 * sizeof (void*) + (FP ? STACK_BIAS : 0))
271 #define STOP_FRAME(CURRENT, TOP_STACK) \
272 ((CURRENT)->return_address == 0|| (CURRENT)->next == 0 \
273 || (void *) (CURRENT) < (TOP_STACK))
275 /* The SPARC register windows need to be flushed before we may access them
276 from the stack. This is achieved by way of builtin_frame_address only
277 when the "count" argument is positive, so force at least one such call. */
278 #define FETCH_UP_FRAME_ADDRESS
281 /* From the frame pointer of frame N, we are accessing the flushed register
282 window of frame N-1 (positive offset from fp), in which we retrieve the
283 saved return address. We then end up with our caller's return address. */
285 /*------------------------------- x86 ----------------------------------*/
291 #define IS_BAD_PTR(ptr) (IsBadCodePtr((void *)ptr))
293 #define IS_BAD_PTR(ptr) 0
296 #define USE_GENERIC_UNWINDER
301 void *return_address;
304 #define LOWEST_ADDR 0
305 #define FRAME_LEVEL 1
306 /* builtin_frame_address (1) is expected to work on this target, and (0) might
307 return the soft stack pointer, which does not designate a location where a
308 backchain and a return address might be found. */
310 #define FRAME_OFFSET(FP) 0
312 #define STOP_FRAME(CURRENT, TOP_STACK) \
313 (IS_BAD_PTR((long)(CURRENT)->return_address) \
314 || (unsigned int)(CURRENT)->return_address < LOWEST_ADDR \
315 || (CURRENT)->return_address == 0|| (CURRENT)->next == 0 \
316 || (void *) (CURRENT) < (TOP_STACK))
318 #define BASE_SKIP (1+FRAME_LEVEL)
320 /* On i386 architecture we check that at the call point we really have a call
321 insn. Possible call instructions are:
323 call addr16 E8 xx xx xx xx
325 call off(reg) FF xx xx
326 lcall addr seg 9A xx xx xx xx xx xx
328 This check will not catch all cases but it will increase the backtrace
329 reliability on this architecture.
332 #define VALID_STACK_FRAME(ptr) \
334 && (((*((ptr) - 3) & 0xff) == 0xe8) \
335 || ((*((ptr) - 5) & 0xff) == 0x9a) \
336 || ((*((ptr) - 1) & 0xff) == 0xff) \
337 || (((*(ptr) & 0xd0ff) == 0xd0ff))))
339 /*----------------------------- x86_64 ---------------------------------*/
341 #elif defined (__x86_64__)
343 #define USE_GCC_UNWINDER
344 /* The generic unwinder is not used for this target because it is based
345 on frame layout assumptions that are not reliable on this target (the
346 rbp register is very likely used for something else than storing the
347 frame pointer in optimized code). Hence, we use the GCC unwinder
348 based on DWARF 2 call frame information, although it has the drawback
349 of not being able to unwind through frames compiled without DWARF 2
354 /* The minimum size of call instructions on this architecture is 2 bytes */
356 /*----------------------------- ia64 ---------------------------------*/
358 #elif defined (__ia64__) && (defined (linux) || defined (__hpux__))
360 #define USE_GCC_UNWINDER
361 /* Use _Unwind_Backtrace driven exceptions on ia64 HP-UX and ia64
362 GNU/Linux, where _Unwind_Backtrace is provided by the system unwind
363 library. On HP-UX 11.23 this requires patch PHSS_33352, which adds
364 _Unwind_Backtrace to the system unwind library. */
371 /*---------------------------------------------------------------------*
372 *-- The post GCC 3.3 infrastructure based implementation --*
373 *---------------------------------------------------------------------*/
375 #if defined (USE_GCC_UNWINDER) && (__GNUC__ * 10 + __GNUC_MINOR__ > 33)
377 /* Conditioning the inclusion on the GCC version is useful to avoid bootstrap
378 path problems, since the included file refers to post 3.3 functions in
379 libgcc, and the stage1 compiler is unlikely to be linked against a post 3.3
380 library. It actually disables the support for backtraces in this compiler
381 for targets defining USE_GCC_UNWINDER, which is OK since we don't use the
382 traceback capability in the compiler anyway.
384 The condition is expressed the way above because we cannot reliably rely on
385 any other macro from the base compiler when compiling stage1. */
389 /*------------------------------------------------------------------*
390 *-- The generic implementation based on frame layout assumptions --*
391 *------------------------------------------------------------------*/
393 #elif defined (USE_GENERIC_UNWINDER)
395 #ifndef CURRENT_STACK_FRAME
396 # define CURRENT_STACK_FRAME ({ char __csf; &__csf; })
399 #ifndef VALID_STACK_FRAME
400 #define VALID_STACK_FRAME(ptr) 1
404 #define MAX(x,y) ((x) > (y) ? (x) : (y))
411 /* Make sure the function is not inlined. */
412 static void forced_callee (void) __attribute__ ((noinline));
414 static void forced_callee (void)
416 /* Make sure the function is not pure. */
417 volatile int i __attribute__ ((unused)) = 0;
421 __gnat_backtrace (void **array,
427 struct layout *current;
435 /* Force a call to builtin_frame_address with a positive argument
436 if required. This is necessary e.g. on SPARC to have the register
437 windows flushed before we attempt to access them on the stack. */
438 #if defined (FETCH_UP_FRAME_ADDRESS) && (FRAME_LEVEL == 0)
439 __builtin_frame_address (1);
442 top_frame = __builtin_frame_address (FRAME_LEVEL);
443 top_stack = CURRENT_STACK_FRAME;
444 current = (struct layout *) ((size_t) top_frame + FRAME_OFFSET (0));
446 /* Skip the number of calls we have been requested to skip, accounting for
447 the BASE_SKIP parameter.
449 FRAME_LEVEL is meaningless for the count adjustment. It impacts where we
450 start retrieving data from, but how many frames "up" we start at is in
451 BASE_SKIP by definition. */
453 skip_frames = MAX (0, skip_frames - BASE_SKIP);
455 while (cnt < skip_frames)
457 current = (struct layout *) ((size_t) current->next + FRAME_OFFSET (1));
464 if (STOP_FRAME (current, top_stack) ||
465 !VALID_STACK_FRAME((char *)(current->return_address + PC_ADJUST)))
468 if (current->return_address < exclude_min
469 || current->return_address > exclude_max)
470 array[cnt++] = current->return_address + PC_ADJUST;
472 current = (struct layout *) ((size_t) current->next + FRAME_OFFSET (1));
480 /* No target specific implementation and neither USE_GCC_UNWINDER not
481 USE_GCC_UNWINDER defined. */
483 /*------------------------------*
484 *-- The dummy implementation --*
485 *------------------------------*/
488 __gnat_backtrace (array, size, exclude_min, exclude_max, skip_frames)
489 void **array ATTRIBUTE_UNUSED;
490 int size ATTRIBUTE_UNUSED;
491 void *exclude_min ATTRIBUTE_UNUSED;
492 void *exclude_max ATTRIBUTE_UNUSED;
493 int skip_frames ATTRIBUTE_UNUSED;