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