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-2014, 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 50extern "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 68extern 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 89extern void (*Lock_Task) (void); 90 91#define Unlock_Task system__soft_links__unlock_task 92extern void (*Unlock_Task) (void); 93 94/*-------------------------------------* 95 *-- Target specific implementations --* 96 *-------------------------------------*/ 97 98#if defined (_WIN64) && defined (__SEH__) 99 100#include <windows.h> 101 102int 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#else 278#error Unhandled darwin architecture. 279#endif 280 281/*---------------------- PPC AIX/PPC Lynx 178/Older Darwin ------------------*/ 282#elif ((defined (_POWER) && defined (_AIX)) || \ 283 (defined (__powerpc__) && defined (__Lynx__) && !defined(__ELF__)) || \ 284 (defined (__ppc__) && defined (__APPLE__))) 285 286#define USE_GENERIC_UNWINDER 287 288struct layout 289{ 290 struct layout *next; 291 void *pad; 292 void *return_address; 293}; 294 295#define FRAME_OFFSET(FP) 0 296#define PC_ADJUST -4 297 298/* Eventhough the base PPC ABI states that a toplevel frame entry 299 should to feature a null backchain, AIX might expose a null return 300 address instead. */ 301 302/* Then LynxOS-178 features yet another variation, with return_address 303 == &<entrypoint>, with two possible entry points (one for the main 304 process and one for threads). Beware that &bla returns the address 305 of a descriptor when "bla" is a function. Getting the code address 306 requires an extra dereference. */ 307 308#if defined (__Lynx__) 309extern void __start(); /* process entry point. */ 310extern void __runnit(); /* thread entry point. */ 311#define EXTRA_STOP_CONDITION(CURRENT) \ 312 ((CURRENT)->return_address == *(void**)&__start \ 313 || (CURRENT)->return_address == *(void**)&__runnit) 314#else 315#define EXTRA_STOP_CONDITION(CURRENT) (0) 316#endif 317 318#define STOP_FRAME(CURRENT, TOP_STACK) \ 319 (((void *) (CURRENT) < (TOP_STACK)) \ 320 || (CURRENT)->return_address == NULL \ 321 || EXTRA_STOP_CONDITION(CURRENT)) 322 323/* The PPC ABI has an interesting specificity: the return address saved by a 324 function is located in it's caller's frame, and the save operation only 325 takes place if the function performs a call. 326 327 To have __gnat_backtrace retrieve its own return address, we then 328 define ... */ 329 330#define FORCE_CALL 1 331#define FRAME_LEVEL 1 332 333#define BASE_SKIP 1 334 335/*-------------------- PPC ELF (GNU/Linux & VxWorks) ---------------------*/ 336 337#elif (defined (_ARCH_PPC) && defined (__vxworks)) || \ 338 (defined (linux) && defined (__powerpc__)) 339 340#define USE_GENERIC_UNWINDER 341 342struct layout 343{ 344 struct layout *next; 345 void *return_address; 346}; 347 348#define FORCE_CALL 1 349#define FRAME_LEVEL 1 350/* See the PPC AIX case for an explanation of these values. */ 351 352#define FRAME_OFFSET(FP) 0 353#define PC_ADJUST -4 354 355/* According to the base PPC ABI, a toplevel frame entry should feature 356 a null backchain. What happens at signal handler frontiers isn't so 357 well specified, so we add a safety guard on top. */ 358 359#define STOP_FRAME(CURRENT, TOP_STACK) \ 360 ((CURRENT)->next == 0 || ((long)(CURRENT)->next % __alignof__(void*)) != 0) 361 362#define BASE_SKIP 1 363 364/*-------------------------- SPARC Solaris -----------------------------*/ 365 366#elif defined (sun) && defined (sparc) 367 368#define USE_GENERIC_UNWINDER 369 370/* These definitions are inspired from the Appendix D (Software 371 Considerations) of the SPARC V8 architecture manual. */ 372 373struct layout 374{ 375 struct layout *next; 376 void *return_address; 377}; 378 379#ifdef __arch64__ 380#define STACK_BIAS 2047 /* V9 ABI */ 381#else 382#define STACK_BIAS 0 /* V8 ABI */ 383#endif 384 385#define FRAME_LEVEL 0 386#define FRAME_OFFSET(FP) (14 * sizeof (void*) + (FP ? STACK_BIAS : 0)) 387#define PC_ADJUST 0 388#define STOP_FRAME(CURRENT, TOP_STACK) \ 389 ((CURRENT)->return_address == 0|| (CURRENT)->next == 0 \ 390 || (void *) (CURRENT) < (TOP_STACK)) 391 392/* The SPARC register windows need to be flushed before we may access them 393 from the stack. This is achieved by way of builtin_frame_address only 394 when the "count" argument is positive, so force at least one such call. */ 395#define FETCH_UP_FRAME_ADDRESS 396 397#define BASE_SKIP 2 398/* From the frame pointer of frame N, we are accessing the flushed register 399 window of frame N-1 (positive offset from fp), in which we retrieve the 400 saved return address. We then end up with our caller's return address. */ 401 402/*------------------------------- x86 ----------------------------------*/ 403 404#elif defined (i386) 405 406#if defined (__WIN32) 407#include <windows.h> 408#define IS_BAD_PTR(ptr) (IsBadCodePtr((FARPROC)ptr)) 409#elif defined (sun) 410#define IS_BAD_PTR(ptr) ((unsigned long)ptr == -1UL) 411#else 412#define IS_BAD_PTR(ptr) 0 413#endif 414 415/* Starting with GCC 4.6, -fomit-frame-pointer is turned on by default for 416 32-bit x86/Linux as well and DWARF 2 unwind tables are emitted instead. 417 See the x86-64 case below for the drawbacks with this approach. */ 418#if defined (linux) && (__GNUC__ * 10 + __GNUC_MINOR__ > 45) 419#define USE_GCC_UNWINDER 420#else 421#define USE_GENERIC_UNWINDER 422#endif 423 424struct layout 425{ 426 struct layout *next; 427 void *return_address; 428}; 429 430#define FRAME_LEVEL 1 431/* builtin_frame_address (1) is expected to work on this target, and (0) might 432 return the soft stack pointer, which does not designate a location where a 433 backchain and a return address might be found. */ 434 435#define FRAME_OFFSET(FP) 0 436#define PC_ADJUST -2 437#define STOP_FRAME(CURRENT, TOP_STACK) \ 438 (IS_BAD_PTR((long)(CURRENT)) \ 439 || IS_BAD_PTR((long)(CURRENT)->return_address) \ 440 || (CURRENT)->return_address == 0 \ 441 || (void *) ((CURRENT)->next) < (TOP_STACK) \ 442 || (void *) (CURRENT) < (TOP_STACK)) 443 444#define BASE_SKIP (1+FRAME_LEVEL) 445 446/* On i386 architecture we check that at the call point we really have a call 447 insn. Possible call instructions are: 448 449 call addr16 E8 xx xx xx xx 450 call reg FF Dx 451 call off(reg) FF xx xx 452 lcall addr seg 9A xx xx xx xx xx xx 453 454 This check will not catch all cases but it will increase the backtrace 455 reliability on this architecture. 456*/ 457 458#define VALID_STACK_FRAME(ptr) \ 459 (!IS_BAD_PTR(ptr) \ 460 && (((*((ptr) - 3) & 0xff) == 0xe8) \ 461 || ((*((ptr) - 5) & 0xff) == 0x9a) \ 462 || ((*((ptr) - 1) & 0xff) == 0xff) \ 463 || (((*(ptr) & 0xd0ff) == 0xd0ff)))) 464 465/*----------------------------- x86_64 ---------------------------------*/ 466 467#elif defined (__x86_64__) 468 469#define USE_GCC_UNWINDER 470/* The generic unwinder is not used for this target because it is based 471 on frame layout assumptions that are not reliable on this target (the 472 rbp register is very likely used for something else than storing the 473 frame pointer in optimized code). Hence, we use the GCC unwinder 474 based on DWARF 2 call frame information, although it has the drawback 475 of not being able to unwind through frames compiled without DWARF 2 476 information. 477*/ 478 479#define PC_ADJUST -2 480/* The minimum size of call instructions on this architecture is 2 bytes */ 481 482/*----------------------------- ia64 ---------------------------------*/ 483 484#elif defined (__ia64__) && (defined (linux) || defined (__hpux__)) 485 486#define USE_GCC_UNWINDER 487/* Use _Unwind_Backtrace driven exceptions on ia64 HP-UX and ia64 488 GNU/Linux, where _Unwind_Backtrace is provided by the system unwind 489 library. On HP-UX 11.23 this requires patch PHSS_33352, which adds 490 _Unwind_Backtrace to the system unwind library. */ 491 492#define PC_ADJUST -4 493 494 495#endif 496 497/*---------------------------------------------------------------------* 498 *-- The post GCC 3.3 infrastructure based implementation --* 499 *---------------------------------------------------------------------*/ 500 501#if defined (USE_GCC_UNWINDER) && (__GNUC__ * 10 + __GNUC_MINOR__ > 33) 502 503/* Conditioning the inclusion on the GCC version is useful to avoid bootstrap 504 path problems, since the included file refers to post 3.3 functions in 505 libgcc, and the stage1 compiler is unlikely to be linked against a post 3.3 506 library. It actually disables the support for backtraces in this compiler 507 for targets defining USE_GCC_UNWINDER, which is OK since we don't use the 508 traceback capability in the compiler anyway. 509 510 The condition is expressed the way above because we cannot reliably rely on 511 any other macro from the base compiler when compiling stage1. */ 512 513#include "tb-gcc.c" 514 515/*------------------------------------------------------------------* 516 *-- The generic implementation based on frame layout assumptions --* 517 *------------------------------------------------------------------*/ 518 519#elif defined (USE_GENERIC_UNWINDER) 520 521#ifndef CURRENT_STACK_FRAME 522# define CURRENT_STACK_FRAME ({ char __csf; &__csf; }) 523#endif 524 525#ifndef VALID_STACK_FRAME 526#define VALID_STACK_FRAME(ptr) 1 527#endif 528 529#ifndef MAX 530#define MAX(x,y) ((x) > (y) ? (x) : (y)) 531#endif 532 533#ifndef FORCE_CALL 534#define FORCE_CALL 0 535#endif 536 537/* Make sure the function is not inlined. */ 538static void forced_callee (void) __attribute__ ((noinline)); 539 540static void forced_callee (void) 541{ 542 /* Make sure the function is not pure. */ 543 volatile int i __attribute__ ((unused)) = 0; 544} 545 546int 547__gnat_backtrace (void **array, 548 int size, 549 void *exclude_min, 550 void *exclude_max, 551 int skip_frames) 552{ 553 struct layout *current; 554 void *top_frame; 555 void *top_stack ATTRIBUTE_UNUSED; 556 int cnt = 0; 557 558 if (FORCE_CALL) 559 forced_callee (); 560 561 /* Force a call to builtin_frame_address with a positive argument 562 if required. This is necessary e.g. on SPARC to have the register 563 windows flushed before we attempt to access them on the stack. */ 564#if defined (FETCH_UP_FRAME_ADDRESS) && (FRAME_LEVEL == 0) 565 __builtin_frame_address (1); 566#endif 567 568 top_frame = __builtin_frame_address (FRAME_LEVEL); 569 top_stack = CURRENT_STACK_FRAME; 570 current = (struct layout *) ((size_t) top_frame + FRAME_OFFSET (0)); 571 572 /* Skip the number of calls we have been requested to skip, accounting for 573 the BASE_SKIP parameter. 574 575 FRAME_LEVEL is meaningless for the count adjustment. It impacts where we 576 start retrieving data from, but how many frames "up" we start at is in 577 BASE_SKIP by definition. */ 578 579 skip_frames = MAX (0, skip_frames - BASE_SKIP); 580 581 while (cnt < skip_frames) 582 { 583 current = (struct layout *) ((size_t) current->next + FRAME_OFFSET (1)); 584 cnt++; 585 } 586 587 cnt = 0; 588 while (cnt < size) 589 { 590 if (STOP_FRAME (current, top_stack) || 591 !VALID_STACK_FRAME(((char *) current->return_address) + PC_ADJUST)) 592 break; 593 594 if (current->return_address < exclude_min 595 || current->return_address > exclude_max) 596 array[cnt++] = ((char *) current->return_address) + PC_ADJUST; 597 598 current = (struct layout *) ((size_t) current->next + FRAME_OFFSET (1)); 599 } 600 601 return cnt; 602} 603 604#else 605 606/* No target specific implementation and neither USE_GCC_UNWINDER nor 607 USE_GENERIC_UNWINDER defined. */ 608 609/*------------------------------* 610 *-- The dummy implementation --* 611 *------------------------------*/ 612 613int 614__gnat_backtrace (void **array ATTRIBUTE_UNUSED, 615 int size ATTRIBUTE_UNUSED, 616 void *exclude_min ATTRIBUTE_UNUSED, 617 void *exclude_max ATTRIBUTE_UNUSED, 618 int skip_frames ATTRIBUTE_UNUSED) 619{ 620 return 0; 621} 622 623#endif 624 625#endif 626 627#ifdef __cplusplus 628} 629#endif 630