1 // -*- C++ -*- 2 //===----------------------- support/win32/support.h ----------------------===// 3 // 4 // The LLVM Compiler Infrastructure 5 // 6 // This file is dual licensed under the MIT and the University of Illinois Open 7 // Source Licenses. See LICENSE.TXT for details. 8 // 9 //===----------------------------------------------------------------------===// 10 11 #ifndef _LIBCPP_SUPPORT_WIN32_SUPPORT_H 12 #define _LIBCPP_SUPPORT_WIN32_SUPPORT_H 13 14 // Functions and constants used in libc++ that 15 // are missing from the Windows C library. 16 17 #include <wchar.h> // mbstate_t 18 #include <cstdarg> // va_ macros 19 // "builtins" not implemented here for Clang or GCC as they provide 20 // implementations. Assuming required for elsewhere else, certainly MSVC. 21 #if defined(_LIBCPP_MSVC) 22 #include <intrin.h> 23 #endif 24 #if defined(_LIBCPP_MSVCRT) 25 #include <xlocinfo.h> 26 #endif 27 #define swprintf _snwprintf 28 #define vswprintf _vsnwprintf 29 30 #ifndef NOMINMAX 31 #define NOMINMAX 32 #endif 33 34 // The mingw headers already define these as static. 35 #ifndef __MINGW32__ 36 extern "C" { 37 38 int vasprintf(char **sptr, const char *__restrict fmt, va_list ap); 39 int asprintf(char **sptr, const char *__restrict fmt, ...); 40 size_t mbsnrtowcs(wchar_t *__restrict dst, const char **__restrict src, 41 size_t nmc, size_t len, mbstate_t *__restrict ps); 42 size_t wcsnrtombs(char *__restrict dst, const wchar_t **__restrict src, 43 size_t nwc, size_t len, mbstate_t *__restrict ps); 44 } 45 #endif // __MINGW32__ 46 47 #if defined(_LIBCPP_MSVCRT) 48 #define snprintf _snprintf 49 #define atoll _atoi64 50 #define strtoll _strtoi64 51 #define strtoull _strtoui64 52 #define wcstoll _wcstoi64 53 #define wcstoull _wcstoui64 54 _LIBCPP_ALWAYS_INLINE float strtof(const char *nptr, char **endptr) 55 { 56 return _Stof(nptr, endptr, 0); 57 } 58 _LIBCPP_ALWAYS_INLINE double strtod(const char *nptr, char **endptr) 59 { 60 return _Stod(nptr, endptr, 0); 61 } 62 _LIBCPP_ALWAYS_INLINE long double strtold(const char *nptr, char **endptr) 63 { 64 return _Stold(nptr, endptr, 0); 65 } 66 67 #define _Exit _exit 68 #endif 69 70 #if defined(_LIBCPP_MSVC) 71 72 // Bit builtin's make these assumptions when calling _BitScanForward/Reverse 73 // etc. These assumptions are expected to be true for Win32/Win64 which this 74 // file supports. 75 static_assert(sizeof(unsigned long long) == 8, ""); 76 static_assert(sizeof(unsigned long) == 4, ""); 77 static_assert(sizeof(unsigned int) == 4, ""); 78 79 _LIBCPP_ALWAYS_INLINE int __builtin_popcount(unsigned int x) 80 { 81 // Binary: 0101... 82 static const unsigned int m1 = 0x55555555; 83 // Binary: 00110011.. 84 static const unsigned int m2 = 0x33333333; 85 // Binary: 4 zeros, 4 ones ... 86 static const unsigned int m4 = 0x0f0f0f0f; 87 // The sum of 256 to the power of 0,1,2,3... 88 static const unsigned int h01 = 0x01010101; 89 // Put count of each 2 bits into those 2 bits. 90 x -= (x >> 1) & m1; 91 // Put count of each 4 bits into those 4 bits. 92 x = (x & m2) + ((x >> 2) & m2); 93 // Put count of each 8 bits into those 8 bits. 94 x = (x + (x >> 4)) & m4; 95 // Returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24). 96 return (x * h01) >> 24; 97 } 98 99 _LIBCPP_ALWAYS_INLINE int __builtin_popcountl(unsigned long x) 100 { 101 return __builtin_popcount(static_cast<int>(x)); 102 } 103 104 _LIBCPP_ALWAYS_INLINE int __builtin_popcountll(unsigned long long x) 105 { 106 // Binary: 0101... 107 static const unsigned long long m1 = 0x5555555555555555; 108 // Binary: 00110011.. 109 static const unsigned long long m2 = 0x3333333333333333; 110 // Binary: 4 zeros, 4 ones ... 111 static const unsigned long long m4 = 0x0f0f0f0f0f0f0f0f; 112 // The sum of 256 to the power of 0,1,2,3... 113 static const unsigned long long h01 = 0x0101010101010101; 114 // Put count of each 2 bits into those 2 bits. 115 x -= (x >> 1) & m1; 116 // Put count of each 4 bits into those 4 bits. 117 x = (x & m2) + ((x >> 2) & m2); 118 // Put count of each 8 bits into those 8 bits. 119 x = (x + (x >> 4)) & m4; 120 // Returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ... 121 return static_cast<int>((x * h01) >> 56); 122 } 123 124 // Returns the number of trailing 0-bits in x, starting at the least significant 125 // bit position. If x is 0, the result is undefined. 126 _LIBCPP_ALWAYS_INLINE int __builtin_ctzll(unsigned long long mask) 127 { 128 unsigned long where; 129 // Search from LSB to MSB for first set bit. 130 // Returns zero if no set bit is found. 131 #if defined(_WIN64) 132 if (_BitScanForward64(&where, mask)) 133 return static_cast<int>(where); 134 #elif defined(_WIN32) 135 // Win32 doesn't have _BitScanForward64 so emulate it with two 32 bit calls. 136 // Scan the Low Word. 137 if (_BitScanForward(&where, static_cast<unsigned long>(mask))) 138 return static_cast<int>(where); 139 // Scan the High Word. 140 if (_BitScanForward(&where, static_cast<unsigned long>(mask >> 32))) 141 return static_cast<int>(where + 32); // Create a bit offset from the LSB. 142 #else 143 #error "Implementation of __builtin_ctzll required" 144 #endif 145 return 64; 146 } 147 148 _LIBCPP_ALWAYS_INLINE int __builtin_ctzl(unsigned long mask) 149 { 150 unsigned long where; 151 // Search from LSB to MSB for first set bit. 152 // Returns zero if no set bit is found. 153 if (_BitScanForward(&where, mask)) 154 return static_cast<int>(where); 155 return 32; 156 } 157 158 _LIBCPP_ALWAYS_INLINE int __builtin_ctz(unsigned int mask) 159 { 160 // Win32 and Win64 expectations. 161 static_assert(sizeof(mask) == 4, ""); 162 static_assert(sizeof(unsigned long) == 4, ""); 163 return __builtin_ctzl(static_cast<unsigned long>(mask)); 164 } 165 166 // Returns the number of leading 0-bits in x, starting at the most significant 167 // bit position. If x is 0, the result is undefined. 168 _LIBCPP_ALWAYS_INLINE int __builtin_clzll(unsigned long long mask) 169 { 170 unsigned long where; 171 // BitScanReverse scans from MSB to LSB for first set bit. 172 // Returns 0 if no set bit is found. 173 #if defined(_WIN64) 174 if (_BitScanReverse64(&where, mask)) 175 return static_cast<int>(63 - where); 176 #elif defined(_WIN32) 177 // Scan the high 32 bits. 178 if (_BitScanReverse(&where, static_cast<unsigned long>(mask >> 32))) 179 return static_cast<int>(63 - 180 (where + 32)); // Create a bit offset from the MSB. 181 // Scan the low 32 bits. 182 if (_BitScanReverse(&where, static_cast<unsigned long>(mask))) 183 return static_cast<int>(63 - where); 184 #else 185 #error "Implementation of __builtin_clzll required" 186 #endif 187 return 64; // Undefined Behavior. 188 } 189 190 _LIBCPP_ALWAYS_INLINE int __builtin_clzl(unsigned long mask) 191 { 192 unsigned long where; 193 // Search from LSB to MSB for first set bit. 194 // Returns zero if no set bit is found. 195 if (_BitScanReverse(&where, mask)) 196 return static_cast<int>(31 - where); 197 return 32; // Undefined Behavior. 198 } 199 200 _LIBCPP_ALWAYS_INLINE int __builtin_clz(unsigned int x) 201 { 202 return __builtin_clzl(x); 203 } 204 #endif // _LIBCPP_MSVC 205 206 #endif // _LIBCPP_SUPPORT_WIN32_SUPPORT_H 207
