gcc/ada/tracebak.c

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