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-2016, 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
 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)
 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 #define USE_GENERIC_UNWINDER
 377
 378 struct layout
 379 {
 380   struct layout *next;
 381   void *return_address;
 382 };
 383
 384 #define FORCE_CALL 1
 385 #define FRAME_LEVEL 1
 386 /* See the PPC AIX case for an explanation of these values.  */
 387
 388 #define FRAME_OFFSET(FP) 0
 389 #define PC_ADJUST -4
 390
 391 /* According to the base PPC ABI, a toplevel frame entry should feature
 392    a null backchain.  What happens at signal handler frontiers isn't so
 393    well specified, so we add a safety guard on top.  */
 394
 395 #define STOP_FRAME(CURRENT, TOP_STACK) \
 396  ((CURRENT)->next == 0 || ((long)(CURRENT)->next % __alignof__(void*)) != 0)
 397
 398 #define BASE_SKIP 1
 399
 400 /*-------------------------- SPARC Solaris -----------------------------*/
 401
 402 #elif defined (__sun__) && defined (__sparc__)
 403
 404 #define USE_GENERIC_UNWINDER
 405
 406 /* These definitions are inspired from the Appendix D (Software
 407    Considerations) of the SPARC V8 architecture manual.  */
 408
 409 struct layout
 410 {
 411   struct layout *next;
 412   void *return_address;
 413 };
 414
 415 #ifdef __arch64__
 416 #define STACK_BIAS 2047 /* V9 ABI */
 417 #else
 418 #define STACK_BIAS 0    /* V8 ABI */
 419 #endif
 420
 421 #define FRAME_LEVEL 0
 422 #define FRAME_OFFSET(FP) (14 * sizeof (void*) + (FP ? STACK_BIAS : 0))
 423 #define PC_ADJUST 0
 424 #define STOP_FRAME(CURRENT, TOP_STACK) \
 425   ((CURRENT)->return_address == 0|| (CURRENT)->next == 0 \
 426    || (void *) (CURRENT) < (TOP_STACK))
 427
 428 /* The SPARC register windows need to be flushed before we may access them
 429    from the stack. This is achieved by way of builtin_frame_address only
 430    when the "count" argument is positive, so force at least one such call.  */
 431 #define FETCH_UP_FRAME_ADDRESS
 432
 433 #define BASE_SKIP 2
 434 /* From the frame pointer of frame N, we are accessing the flushed register
 435    window of frame N-1 (positive offset from fp), in which we retrieve the
 436    saved return address. We then end up with our caller's return address.  */
 437
 438 /*---------------------------- x86 & x86_64 ---------------------------------*/
 439
 440 #elif defined (__i386__) || defined (__x86_64__)
 441
 442 #if defined (__WIN32)
 443 #include <windows.h>
 444 #define IS_BAD_PTR(ptr) (IsBadCodePtr((FARPROC)ptr))
 445 #elif defined (__sun__)
 446 #define IS_BAD_PTR(ptr) ((unsigned long)ptr == -1UL)
 447 #else
 448 #define IS_BAD_PTR(ptr) 0
 449 #endif
 450
 451 /* Use the dwarf2 unwinder when we expect to have dwarf2 tables at
 452    hand. Backtraces will reliably stop on frames missing such tables,
 453    but our only alternative is the generic unwinder which requires
 454    compilation forcing a frame pointer to be reliable.  */
 455
 456 #if (defined (__x86_64__) || defined (__linux__)) && !defined (__USING_SJLJ_EXCEPTIONS__)
 457 #define USE_GCC_UNWINDER
 458 #else
 459 #define USE_GENERIC_UNWINDER
 460 #endif
 461
 462 struct layout
 463 {
 464   struct layout *next;
 465   void *return_address;
 466 };
 467
 468 #define FRAME_LEVEL 1
 469 /* builtin_frame_address (1) is expected to work on this family of targets,
 470    and (0) might return the soft stack pointer, which does not designate a
 471    location where a backchain and a return address might be found.  */
 472
 473 #define FRAME_OFFSET(FP) 0
 474 #define PC_ADJUST -2
 475 #define STOP_FRAME(CURRENT, TOP_STACK) \
 476   (IS_BAD_PTR((long)(CURRENT)) \
 477    || IS_BAD_PTR((long)(CURRENT)->return_address) \
 478    || (CURRENT)->return_address == 0 \
 479    || (void *) ((CURRENT)->next) < (TOP_STACK)  \
 480    || (void *) (CURRENT) < (TOP_STACK))
 481
 482 #define BASE_SKIP (1+FRAME_LEVEL)
 483
 484 /* On i386 architecture we check that at the call point we really have a call
 485    insn. Possible call instructions are:
 486
 487    call  addr16        E8 xx xx xx xx
 488    call  reg           FF Dx
 489    call  off(reg)      FF xx xx
 490    lcall addr seg      9A xx xx xx xx xx xx
 491
 492    This check will not catch all cases but it will increase the backtrace
 493    reliability on this architecture.
 494 */
 495
 496 #define VALID_STACK_FRAME(ptr) \
 497    (!IS_BAD_PTR(ptr) \
 498     && (((*((ptr) - 3) & 0xff) == 0xe8) \
 499         || ((*((ptr) - 5) & 0xff) == 0x9a) \
 500         || ((*((ptr) - 1) & 0xff) == 0xff) \
 501         || (((*(ptr) & 0xd0ff) == 0xd0ff))))
 502
 503 /*----------------------------- ia64 ---------------------------------*/
 504
 505 #elif defined (__ia64__) && (defined (__linux__) || defined (__hpux__))
 506
 507 #define USE_GCC_UNWINDER
 508 /* Use _Unwind_Backtrace driven exceptions on ia64 HP-UX and ia64
 509    GNU/Linux, where _Unwind_Backtrace is provided by the system unwind
 510    library. On HP-UX 11.23 this requires patch PHSS_33352, which adds
 511    _Unwind_Backtrace to the system unwind library. */
 512
 513 #define PC_ADJUST -4
 514
 515
 516 #endif
 517
 518 /*---------------------------------------------------------------------*
 519  *--      The post GCC 3.3 infrastructure based implementation       --*
 520  *---------------------------------------------------------------------*/
 521
 522 #if defined (USE_GCC_UNWINDER) && (__GNUC__ * 10 + __GNUC_MINOR__ > 33)
 523
 524 /* Conditioning the inclusion on the GCC version is useful to avoid bootstrap
 525    path problems, since the included file refers to post 3.3 functions in
 526    libgcc, and the stage1 compiler is unlikely to be linked against a post 3.3
 527    library.  It actually disables the support for backtraces in this compiler
 528    for targets defining USE_GCC_UNWINDER, which is OK since we don't use the
 529    traceback capability in the compiler anyway.
 530
 531    The condition is expressed the way above because we cannot reliably rely on
 532    any other macro from the base compiler when compiling stage1.  */
 533
 534 #ifdef USING_ARM_UNWINDING
 535 /* This value is not part of the enumerated reason codes defined in unwind.h
 536    for ARM style unwinding, but is used in the included "C" code, so we
 537    define it to a reasonable value to avoid a compilation error.  */
 538 #define _URC_NORMAL_STOP 0
 539 #endif
 540 #include "tb-gcc.c"
 541
 542 /*------------------------------------------------------------------*
 543  *-- The generic implementation based on frame layout assumptions --*
 544  *------------------------------------------------------------------*/
 545
 546 #elif defined (USE_GENERIC_UNWINDER)
 547
 548 #ifndef CURRENT_STACK_FRAME
 549 # define CURRENT_STACK_FRAME  ({ char __csf; &__csf; })
 550 #endif
 551
 552 #ifndef VALID_STACK_FRAME
 553 #define VALID_STACK_FRAME(ptr) 1
 554 #endif
 555
 556 #ifndef MAX
 557 #define MAX(x,y) ((x) > (y) ? (x) : (y))
 558 #endif
 559
 560 #ifndef FORCE_CALL
 561 #define FORCE_CALL 0
 562 #endif
 563
 564 /* Make sure the function is not inlined.  */
 565 static void forced_callee (void) __attribute__ ((noinline));
 566
 567 static void forced_callee (void)
 568 {
 569   /* Make sure the function is not pure.  */
 570   volatile int i __attribute__ ((unused)) = 0;
 571 }
 572
 573 int
 574 __gnat_backtrace (void **array,
 575                   int size,
 576                   void *exclude_min,
 577                   void *exclude_max,
 578                   int skip_frames)
 579 {
 580   struct layout *current;
 581   void *top_frame;
 582   void *top_stack ATTRIBUTE_UNUSED;
 583   int cnt = 0;
 584
 585   if (FORCE_CALL)
 586     forced_callee ();
 587
 588   /* Force a call to builtin_frame_address with a positive argument
 589      if required. This is necessary e.g. on SPARC to have the register
 590      windows flushed before we attempt to access them on the stack.  */
 591 #if defined (FETCH_UP_FRAME_ADDRESS) && (FRAME_LEVEL == 0)
 592   __builtin_frame_address (1);
 593 #endif
 594
 595   top_frame = __builtin_frame_address (FRAME_LEVEL);
 596   top_stack = CURRENT_STACK_FRAME;
 597   current = (struct layout *) ((size_t) top_frame + FRAME_OFFSET (0));
 598
 599   /* Skip the number of calls we have been requested to skip, accounting for
 600      the BASE_SKIP parameter.
 601
 602      FRAME_LEVEL is meaningless for the count adjustment. It impacts where we
 603      start retrieving data from, but how many frames "up" we start at is in
 604      BASE_SKIP by definition.  */
 605
 606   skip_frames = MAX (0, skip_frames - BASE_SKIP);
 607
 608   while (cnt < skip_frames)
 609     {
 610       current = (struct layout *) ((size_t) current->next + FRAME_OFFSET (1));
 611       cnt++;
 612     }
 613
 614   cnt = 0;
 615   while (cnt < size)
 616     {
 617       if (STOP_FRAME (current, top_stack) ||
 618           !VALID_STACK_FRAME(((char *) current->return_address) + PC_ADJUST))
 619         break;
 620
 621       if (current->return_address < exclude_min
 622           || current->return_address > exclude_max)
 623         array[cnt++] = ((char *) current->return_address) + PC_ADJUST;
 624
 625       current = (struct layout *) ((size_t) current->next + FRAME_OFFSET (1));
 626     }
 627
 628   return cnt;
 629 }
 630
 631 #else
 632
 633 /* No target specific implementation and neither USE_GCC_UNWINDER nor
 634    USE_GENERIC_UNWINDER defined.  */
 635
 636 /*------------------------------*
 637  *-- The dummy implementation --*
 638  *------------------------------*/
 639
 640 int
 641 __gnat_backtrace (void **array ATTRIBUTE_UNUSED,
 642                   int size ATTRIBUTE_UNUSED,
 643                   void *exclude_min ATTRIBUTE_UNUSED,
 644                   void *exclude_max ATTRIBUTE_UNUSED,
 645                   int skip_frames ATTRIBUTE_UNUSED)
 646 {
 647   return 0;
 648 }
 649
 650 #endif
 651
 652 #endif
 653
 654 #ifdef __cplusplus
 655 }
 656 #endif