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