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