libgcc/libgcc2.h

   1 /* Header file for libgcc2.c.  */
   2 /* Copyright (C) 2000-2013 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 Under Section 7 of GPL version 3, you are granted additional
  17 permissions described in the GCC Runtime Library Exception, version
  18 3.1, as published by the Free Software Foundation.
  19
  20 You should have received a copy of the GNU General Public License and
  21 a copy of the GCC Runtime Library Exception along with this program;
  22 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25 #ifndef GCC_LIBGCC2_H
  26 #define GCC_LIBGCC2_H
  27
  28 #ifndef HIDE_EXPORTS
  29 #pragma GCC visibility push(default)
  30 #endif
  31
  32 extern int __gcc_bcmp (const unsigned char *, const unsigned char *, size_t);
  33 extern void __clear_cache (char *, char *);
  34 extern void __eprintf (const char *, const char *, unsigned int, const char *)
  35   __attribute__ ((__noreturn__));
  36
  37 #ifndef LIBGCC2_LONG_DOUBLE_TYPE_SIZE
  38 #define LIBGCC2_LONG_DOUBLE_TYPE_SIZE LONG_DOUBLE_TYPE_SIZE
  39 #endif
  40
  41 #ifndef LIBGCC2_HAS_SF_MODE
  42 #define LIBGCC2_HAS_SF_MODE (BITS_PER_UNIT == 8)
  43 #endif
  44
  45 #ifndef LIBGCC2_HAS_DF_MODE
  46 #define LIBGCC2_HAS_DF_MODE \
  47   (BITS_PER_UNIT == 8 \
  48    && (__SIZEOF_DOUBLE__ * __CHAR_BIT__ == 64 \
  49        || LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 64))
  50 #endif
  51
  52 #ifndef LIBGCC2_HAS_XF_MODE
  53 #define LIBGCC2_HAS_XF_MODE \
  54   (BITS_PER_UNIT == 8 && LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 80)
  55 #endif
  56
  57 #ifndef LIBGCC2_HAS_TF_MODE
  58 #define LIBGCC2_HAS_TF_MODE \
  59   (BITS_PER_UNIT == 8 && LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
  60 #endif
  61
  62 #ifndef SF_SIZE
  63 #if LIBGCC2_HAS_SF_MODE
  64 #define SF_SIZE FLT_MANT_DIG
  65 #else
  66 #define SF_SIZE 0
  67 #endif
  68 #endif
  69
  70 #ifndef DF_SIZE
  71 #if LIBGCC2_HAS_DF_MODE
  72 #if __SIZEOF_DOUBLE__ * __CHAR_BIT__ == 64
  73 #define DF_SIZE DBL_MANT_DIG
  74 #elif LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 64
  75 #define DF_SIZE LDBL_MANT_DIG
  76 #else
  77 #define DF_SIZE 0
  78 #endif
  79 #else
  80 #define DF_SIZE 0
  81 #endif
  82 #endif
  83
  84 #ifndef XF_SIZE
  85 #if LIBGCC2_HAS_XF_MODE
  86 #define XF_SIZE LDBL_MANT_DIG
  87 #else
  88 #define XF_SIZE 0
  89 #endif
  90 #endif
  91
  92 #ifndef TF_SIZE
  93 #if LIBGCC2_HAS_TF_MODE
  94 #define TF_SIZE LDBL_MANT_DIG
  95 #else
  96 #define TF_SIZE 0
  97 #endif
  98 #endif
  99
 100 /* FIXME: This #ifdef probably should be removed, ie. enable the test
 101    for mips too.  */
 102 /* Don't use IBM Extended Double TFmode for TI->SF calculations.
 103    The conversion from long double to float suffers from double
 104    rounding, because we convert via double.  In other cases, going
 105    through the software fp routines is much slower than the fallback.  */
 106 #ifdef __powerpc__
 107 #define AVOID_FP_TYPE_CONVERSION(SIZE) (SIZE == 106)
 108 #elif defined(WIDEST_HARDWARE_FP_SIZE)
 109 #define AVOID_FP_TYPE_CONVERSION(SIZE) (SIZE > WIDEST_HARDWARE_FP_SIZE)
 110 #else
 111 #define AVOID_FP_TYPE_CONVERSION(SIZE) 0
 112 #endif
 113
 114 /* In the first part of this file, we are interfacing to calls generated
 115    by the compiler itself.  These calls pass values into these routines
 116    which have very specific modes (rather than very specific types), and
 117    these compiler-generated calls also expect any return values to have
 118    very specific modes (rather than very specific types).  Thus, we need
 119    to avoid using regular C language type names in this part of the file
 120    because the sizes for those types can be configured to be anything.
 121    Instead we use the following special type names.  */
 122
 123 typedef          int QItype     __attribute__ ((mode (QI)));
 124 typedef unsigned int UQItype    __attribute__ ((mode (QI)));
 125 typedef          int HItype     __attribute__ ((mode (HI)));
 126 typedef unsigned int UHItype    __attribute__ ((mode (HI)));
 127 #if MIN_UNITS_PER_WORD > 1
 128 /* These typedefs are usually forbidden on dsp's with UNITS_PER_WORD 1.  */
 129 typedef          int SItype     __attribute__ ((mode (SI)));
 130 typedef unsigned int USItype    __attribute__ ((mode (SI)));
 131 #if __SIZEOF_LONG_LONG__ > 4
 132 /* These typedefs are usually forbidden on archs with UNITS_PER_WORD 2.  */
 133 typedef          int DItype     __attribute__ ((mode (DI)));
 134 typedef unsigned int UDItype    __attribute__ ((mode (DI)));
 135 #if MIN_UNITS_PER_WORD > 4
 136 /* These typedefs are usually forbidden on archs with UNITS_PER_WORD 4.  */
 137 typedef          int TItype     __attribute__ ((mode (TI)));
 138 typedef unsigned int UTItype    __attribute__ ((mode (TI)));
 139 #endif
 140 #endif
 141 #endif
 142
 143 #if LIBGCC2_HAS_SF_MODE
 144 typedef         float SFtype    __attribute__ ((mode (SF)));
 145 typedef _Complex float SCtype   __attribute__ ((mode (SC)));
 146 #endif
 147 #if LIBGCC2_HAS_DF_MODE
 148 typedef         float DFtype    __attribute__ ((mode (DF)));
 149 typedef _Complex float DCtype   __attribute__ ((mode (DC)));
 150 #endif
 151 #if LIBGCC2_HAS_XF_MODE
 152 typedef         float XFtype    __attribute__ ((mode (XF)));
 153 typedef _Complex float XCtype   __attribute__ ((mode (XC)));
 154 #endif
 155 #if LIBGCC2_HAS_TF_MODE
 156 typedef         float TFtype    __attribute__ ((mode (TF)));
 157 typedef _Complex float TCtype   __attribute__ ((mode (TC)));
 158 #endif
 159
 160 typedef int cmp_return_type __attribute__((mode (__libgcc_cmp_return__)));
 161 typedef int shift_count_type __attribute__((mode (__libgcc_shift_count__)));
 162
 163 /* Make sure that we don't accidentally use any normal C language built-in
 164    type names in the first part of this file.  Instead we want to use *only*
 165    the type names defined above.  The following macro definitions insure
 166    that if we *do* accidentally use some normal C language built-in type name,
 167    we will get a syntax error.  */
 168
 169 #define char bogus_type
 170 #define short bogus_type
 171 #define int bogus_type
 172 #define long bogus_type
 173 #define unsigned bogus_type
 174 #define float bogus_type
 175 #define double bogus_type
 176
 177 /* Versions prior to 3.4.4 were not taking into account the word size for
 178    the 5 trapping arithmetic functions absv, addv, subv, mulv and negv.  As
 179    a consequence, the si and di variants were always and the only ones emitted.
 180    To maintain backward compatibility, COMPAT_SIMODE_TRAPPING_ARITHMETIC is
 181    defined on platforms where it makes sense to still have the si variants
 182    emitted.  As a bonus, their implementation is now correct.  Note that the
 183    same mechanism should have been implemented for the di variants, but it
 184    turns out that no platform would define COMPAT_DIMODE_TRAPPING_ARITHMETIC
 185    if it existed.  */
 186
 187 #if LIBGCC2_UNITS_PER_WORD == 8
 188 #define W_TYPE_SIZE (8 * BITS_PER_UNIT)
 189 #define Wtype   DItype
 190 #define UWtype  UDItype
 191 #define HWtype  DItype
 192 #define UHWtype UDItype
 193 #define DWtype  TItype
 194 #define UDWtype UTItype
 195 #ifdef LIBGCC2_GNU_PREFIX
 196 #define __NW(a,b)       __gnu_ ## a ## di ## b
 197 #define __NDW(a,b)      __gnu_ ## a ## ti ## b
 198 #else
 199 #define __NW(a,b)       __ ## a ## di ## b
 200 #define __NDW(a,b)      __ ## a ## ti ## b
 201 #endif
 202 #define COMPAT_SIMODE_TRAPPING_ARITHMETIC
 203 #elif LIBGCC2_UNITS_PER_WORD == 4
 204 #define W_TYPE_SIZE (4 * BITS_PER_UNIT)
 205 #define Wtype   SItype
 206 #define UWtype  USItype
 207 #define HWtype  SItype
 208 #define UHWtype USItype
 209 #define DWtype  DItype
 210 #define UDWtype UDItype
 211 #ifdef LIBGCC2_GNU_PREFIX
 212 #define __NW(a,b)       __gnu_ ## a ## si ## b
 213 #define __NDW(a,b)      __gnu_ ## a ## di ## b
 214 #else
 215 #define __NW(a,b)       __ ## a ## si ## b
 216 #define __NDW(a,b)      __ ## a ## di ## b
 217 #endif
 218 #elif LIBGCC2_UNITS_PER_WORD == 2
 219 #define W_TYPE_SIZE (2 * BITS_PER_UNIT)
 220 #define Wtype   HItype
 221 #define UWtype  UHItype
 222 #define HWtype  HItype
 223 #define UHWtype UHItype
 224 #define DWtype  SItype
 225 #define UDWtype USItype
 226 #ifdef LIBGCC2_GNU_PREFIX
 227 #define __NW(a,b)       __gnu_ ## a ## hi ## b
 228 #define __NDW(a,b)      __gnu_ ## a ## si ## b
 229 #else
 230 #define __NW(a,b)       __ ## a ## hi ## b
 231 #define __NDW(a,b)      __ ## a ## si ## b
 232 #endif
 233 #else
 234 #define W_TYPE_SIZE BITS_PER_UNIT
 235 #define Wtype   QItype
 236 #define UWtype  UQItype
 237 #define HWtype  QItype
 238 #define UHWtype UQItype
 239 #define DWtype  HItype
 240 #define UDWtype UHItype
 241 #ifdef LIBGCC2_GNU_PREFIX
 242 #define __NW(a,b)       __gnu_ ## a ## qi ## b
 243 #define __NDW(a,b)      __gnu_ ## a ## hi ## b
 244 #else
 245 #define __NW(a,b)       __ ## a ## qi ## b
 246 #define __NDW(a,b)      __ ## a ## hi ## b
 247 #endif
 248 #endif
 249
 250 #ifdef LIBGCC2_GNU_PREFIX
 251 #define __N(a)  __gnu_ ## a
 252 #else
 253 #define __N(a)  __ ## a
 254 #endif
 255 #define Wtype_MAX ((Wtype)(((UWtype)1 << (W_TYPE_SIZE - 1)) - 1))
 256 #define Wtype_MIN (- Wtype_MAX - 1)
 257
 258 #if W_TYPE_SIZE == 8
 259 # define Wtype_MAXp1_F  0x1p8f
 260 #elif W_TYPE_SIZE == 16
 261 # define Wtype_MAXp1_F  0x1p16f
 262 #elif W_TYPE_SIZE == 32
 263 # define Wtype_MAXp1_F  0x1p32f
 264 #elif W_TYPE_SIZE == 64
 265 # define Wtype_MAXp1_F  0x1p64f
 266 #else
 267 # error "expand the table"
 268 #endif
 269
 270 #define __muldi3        __NDW(mul,3)
 271 #define __divdi3        __NDW(div,3)
 272 #define __udivdi3       __NDW(udiv,3)
 273 #define __moddi3        __NDW(mod,3)
 274 #define __umoddi3       __NDW(umod,3)
 275 #define __negdi2        __NDW(neg,2)
 276 #define __lshrdi3       __NDW(lshr,3)
 277 #define __ashldi3       __NDW(ashl,3)
 278 #define __ashrdi3       __NDW(ashr,3)
 279 #define __cmpdi2        __NDW(cmp,2)
 280 #define __ucmpdi2       __NDW(ucmp,2)
 281 #define __udivmoddi4    __NDW(udivmod,4)
 282 #define __fixunstfDI    __NDW(fixunstf,)
 283 #define __fixtfdi       __NDW(fixtf,)
 284 #define __fixunsxfDI    __NDW(fixunsxf,)
 285 #define __fixxfdi       __NDW(fixxf,)
 286 #define __fixunsdfDI    __NDW(fixunsdf,)
 287 #define __fixdfdi       __NDW(fixdf,)
 288 #define __fixunssfDI    __NDW(fixunssf,)
 289 #define __fixsfdi       __NDW(fixsf,)
 290 #define __floatdixf     __NDW(float,xf)
 291 #define __floatditf     __NDW(float,tf)
 292 #define __floatdidf     __NDW(float,df)
 293 #define __floatdisf     __NDW(float,sf)
 294 #define __floatundixf   __NDW(floatun,xf)
 295 #define __floatunditf   __NDW(floatun,tf)
 296 #define __floatundidf   __NDW(floatun,df)
 297 #define __floatundisf   __NDW(floatun,sf)
 298 #define __fixunsxfSI    __NW(fixunsxf,)
 299 #define __fixunstfSI    __NW(fixunstf,)
 300 #define __fixunsdfSI    __NW(fixunsdf,)
 301 #define __fixunssfSI    __NW(fixunssf,)
 302
 303 #define __absvSI2       __NW(absv,2)
 304 #define __addvSI3       __NW(addv,3)
 305 #define __subvSI3       __NW(subv,3)
 306 #define __mulvSI3       __NW(mulv,3)
 307 #define __negvSI2       __NW(negv,2)
 308 #define __absvDI2       __NDW(absv,2)
 309 #define __addvDI3       __NDW(addv,3)
 310 #define __subvDI3       __NDW(subv,3)
 311 #define __mulvDI3       __NDW(mulv,3)
 312 #define __negvDI2       __NDW(negv,2)
 313
 314 #define __ffsSI2        __NW(ffs,2)
 315 #define __clzSI2        __NW(clz,2)
 316 #define __ctzSI2        __NW(ctz,2)
 317 #define __clrsbSI2      __NW(clrsb,2)
 318 #define __popcountSI2   __NW(popcount,2)
 319 #define __paritySI2     __NW(parity,2)
 320 #define __ffsDI2        __NDW(ffs,2)
 321 #define __clzDI2        __NDW(clz,2)
 322 #define __ctzDI2        __NDW(ctz,2)
 323 #define __clrsbDI2      __NDW(clrsb,2)
 324 #define __popcountDI2   __NDW(popcount,2)
 325 #define __parityDI2     __NDW(parity,2)
 326
 327 #define __clz_tab               __N(clz_tab)
 328 #define __bswapsi2              __N(bswapsi2)
 329 #define __bswapdi2              __N(bswapdi2)
 330 #define __udiv_w_sdiv           __N(udiv_w_sdiv)
 331 #define __clear_cache           __N(clear_cache)
 332 #define __enable_execute_stack  __N(enable_execute_stack)
 333
 334 #ifndef __powisf2
 335 #define __powisf2               __N(powisf2)
 336 #endif
 337 #ifndef __powidf2
 338 #define __powidf2               __N(powidf2)
 339 #endif
 340 #ifndef __powitf2
 341 #define __powitf2               __N(powitf2)
 342 #endif
 343 #ifndef __powixf2
 344 #define __powixf2               __N(powixf2)
 345 #endif
 346 #ifndef __mulsc3
 347 #define __mulsc3                __N(mulsc3)
 348 #endif
 349 #ifndef __muldc3
 350 #define __muldc3                __N(muldc3)
 351 #endif
 352 #ifndef __mulxc3
 353 #define __mulxc3                __N(mulxc3)
 354 #endif
 355 #ifndef __multc3
 356 #define __multc3                __N(multc3)
 357 #endif
 358 #ifndef __divsc3
 359 #define __divsc3                __N(divsc3)
 360 #endif
 361 #ifndef __divdc3
 362 #define __divdc3                __N(divdc3)
 363 #endif
 364 #ifndef __divxc3
 365 #define __divxc3                __N(divxc3)
 366 #endif
 367 #ifndef __divtc3
 368 #define __divtc3                __N(divtc3)
 369 #endif
 370
 371 extern DWtype __muldi3 (DWtype, DWtype);
 372 extern DWtype __divdi3 (DWtype, DWtype);
 373 extern UDWtype __udivdi3 (UDWtype, UDWtype);
 374 extern UDWtype __umoddi3 (UDWtype, UDWtype);
 375 extern DWtype __moddi3 (DWtype, DWtype);
 376
 377 /* __udivmoddi4 is static inline when building other libgcc2 portions.  */
 378 #if (!defined (L_udivdi3) && !defined (L_divdi3) && \
 379      !defined (L_umoddi3) && !defined (L_moddi3))
 380 extern UDWtype __udivmoddi4 (UDWtype, UDWtype, UDWtype *);
 381 #endif
 382
 383 /* __negdi2 is static inline when building other libgcc2 portions.  */
 384 #if !defined(L_divdi3) && !defined(L_moddi3)
 385 extern DWtype __negdi2 (DWtype);
 386 #endif
 387
 388 extern DWtype __lshrdi3 (DWtype, shift_count_type);
 389 extern DWtype __ashldi3 (DWtype, shift_count_type);
 390 extern DWtype __ashrdi3 (DWtype, shift_count_type);
 391
 392 /* __udiv_w_sdiv is static inline when building other libgcc2 portions.  */
 393 #if (!defined(L_udivdi3) && !defined(L_divdi3) && \
 394      !defined(L_umoddi3) && !defined(L_moddi3))
 395 extern UWtype __udiv_w_sdiv (UWtype *, UWtype, UWtype, UWtype);
 396 #endif
 397
 398 extern cmp_return_type __cmpdi2 (DWtype, DWtype);
 399 extern cmp_return_type __ucmpdi2 (DWtype, DWtype);
 400
 401 #if MIN_UNITS_PER_WORD > 1
 402 extern SItype __bswapsi2 (SItype);
 403 #endif
 404 #if __SIZEOF_LONG_LONG__ > 4
 405 extern DItype __bswapdi2 (DItype);
 406 #endif
 407
 408 extern Wtype __absvSI2 (Wtype);
 409 extern Wtype __addvSI3 (Wtype, Wtype);
 410 extern Wtype __subvSI3 (Wtype, Wtype);
 411 extern Wtype __mulvSI3 (Wtype, Wtype);
 412 extern Wtype __negvSI2 (Wtype);
 413 extern DWtype __absvDI2 (DWtype);
 414 extern DWtype __addvDI3 (DWtype, DWtype);
 415 extern DWtype __subvDI3 (DWtype, DWtype);
 416 extern DWtype __mulvDI3 (DWtype, DWtype);
 417 extern DWtype __negvDI2 (DWtype);
 418
 419 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
 420 #define __absvsi2       __N(absvsi2)
 421 #define __negvsi2       __N(negvsi2)
 422 #define __addvsi3       __N(addvsi3)
 423 #define __subvsi3       __N(subvsi3)
 424 #define __mulvsi3       __N(mulvsi3)
 425
 426 extern SItype __absvsi2 (SItype);
 427 extern SItype __addvsi3 (SItype, SItype);
 428 extern SItype __subvsi3 (SItype, SItype);
 429 extern SItype __mulvsi3 (SItype, SItype);
 430 extern SItype __negvsi2 (SItype);
 431 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
 432
 433 #undef int
 434 #if LIBGCC2_HAS_SF_MODE
 435 extern DWtype __fixsfdi (SFtype);
 436 extern SFtype __floatdisf (DWtype);
 437 extern SFtype __floatundisf (UDWtype);
 438 extern UWtype __fixunssfSI (SFtype);
 439 extern UDWtype __fixunssfDI (SFtype);
 440 extern SFtype __powisf2 (SFtype, int);
 441 extern SCtype __divsc3 (SFtype, SFtype, SFtype, SFtype);
 442 extern SCtype __mulsc3 (SFtype, SFtype, SFtype, SFtype);
 443 #endif
 444 #if LIBGCC2_HAS_DF_MODE
 445 extern DWtype __fixdfdi (DFtype);
 446 extern DFtype __floatdidf (DWtype);
 447 extern DFtype __floatundidf (UDWtype);
 448 extern UWtype __fixunsdfSI (DFtype);
 449 extern UDWtype __fixunsdfDI (DFtype);
 450 extern DFtype __powidf2 (DFtype, int);
 451 extern DCtype __divdc3 (DFtype, DFtype, DFtype, DFtype);
 452 extern DCtype __muldc3 (DFtype, DFtype, DFtype, DFtype);
 453 #endif
 454
 455 #if LIBGCC2_HAS_XF_MODE
 456 extern DWtype __fixxfdi (XFtype);
 457 extern UDWtype __fixunsxfDI (XFtype);
 458 extern XFtype __floatdixf (DWtype);
 459 extern XFtype __floatundixf (UDWtype);
 460 extern UWtype __fixunsxfSI (XFtype);
 461 extern XFtype __powixf2 (XFtype, int);
 462 extern XCtype __divxc3 (XFtype, XFtype, XFtype, XFtype);
 463 extern XCtype __mulxc3 (XFtype, XFtype, XFtype, XFtype);
 464 #endif
 465
 466 #if LIBGCC2_HAS_TF_MODE
 467 extern UDWtype __fixunstfDI (TFtype);
 468 extern DWtype __fixtfdi (TFtype);
 469 extern TFtype __floatditf (DWtype);
 470 extern TFtype __floatunditf (UDWtype);
 471 extern TFtype __powitf2 (TFtype, int);
 472 extern TCtype __divtc3 (TFtype, TFtype, TFtype, TFtype);
 473 extern TCtype __multc3 (TFtype, TFtype, TFtype, TFtype);
 474 #endif
 475 #define int bogus_type
 476
 477 /* DWstructs are pairs of Wtype values in the order determined by
 478    __BYTE_ORDER__.  */
 479
 480 #if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__
 481   struct DWstruct {Wtype high, low;};
 482 #else
 483   struct DWstruct {Wtype low, high;};
 484 #endif
 485
 486 /* We need this union to unpack/pack DImode values, since we don't have
 487    any arithmetic yet.  Incoming DImode parameters are stored into the
 488    `ll' field, and the unpacked result is read from the struct `s'.  */
 489
 490 typedef union
 491 {
 492   struct DWstruct s;
 493   DWtype ll;
 494 } DWunion;
 495
 496 /* Defined for L_popcount_tab.  Exported here because some targets may
 497    want to use it for their own versions of the __popcount builtins.  */
 498 extern const UQItype __popcount_tab[256];
 499
 500 /* Defined for L_clz.  Exported here because some targets may want to use
 501    it for their own versions of the __clz builtins.  It contains the bit
 502    position of the first set bit for the numbers 0 - 255.  This avoids the
 503    need for a separate table for the __ctz builtins.  */
 504 extern const UQItype __clz_tab[256];
 505
 506 #include "longlong.h"
 507
 508 #undef int
 509 extern int __clzDI2 (UDWtype);
 510 extern int __clzSI2 (UWtype);
 511 extern int __ctzSI2 (UWtype);
 512 extern int __ctzDI2 (UDWtype);
 513 extern int __clrsbSI2 (Wtype);
 514 extern int __clrsbDI2 (DWtype);
 515 extern int __ffsSI2 (UWtype);
 516 extern int __ffsDI2 (DWtype);
 517 extern int __popcountSI2 (UWtype);
 518 extern int __popcountDI2 (UDWtype);
 519 extern int __paritySI2 (UWtype);
 520 extern int __parityDI2 (UDWtype);
 521 #define int bogus_type
 522
 523 extern void __enable_execute_stack (void *);
 524
 525 #ifndef HIDE_EXPORTS
 526 #pragma GCC visibility pop
 527 #endif
 528
 529 #endif /* ! GCC_LIBGCC2_H */