This is an archive of the discontinued LLVM Phabricator instance.

Differential D32988

[libc++] Refactor Windows support headers.
ClosedPublic

Authored by EricWF on May 8 2017, 6:34 PM.

Details

Reviewers
bcraig
rmaprath
compnerd
EricWF
Commits
rG5d50aa320415: [libc++] Refactor Windows support headers.
rCXX302727: [libc++] Refactor Windows support headers.
rL302727: [libc++] Refactor Windows support headers.
Summary

This patch refactors and tries to remove as much of the Windows support headers as possible. This is needed because they currently introduce super weird include cycles and dependencies between STL and libc headers.

The changes in this patch are:

  • remove support/win32/support.h completely. The required parts have either been moved into support/win32/msvc_support.h (for MSVC only helpers not needed by Clang), or directly into their respective foo.h headers.
  • Combine locale_win32.h and locale_mgmt_win32.h into a single headers, this header should only be included within __locale or locale to avoid include cycles.
  • Remove the unneeded parts of limits_win32.h and re-name it to limits_msvc_win32.h since it's only needed by Clang.

I've tested this patch using Clang on Windows, but I suspect it might technically regress our non-existent support for MSVC. Is somebody able to double check?

This refactor is needed to support upcoming fixes to <locale> on Windows.

Diff Detail

Repository
rL LLVM

Event Timeline

EricWF created this revision.May 8 2017, 6:34 PM
EricWF updated this revision to Diff 98246.May 8 2017, 6:44 PM
  • Rename msvc_support.h to msvc_builtin_support.h.
EricWF planned changes to this revision.May 8 2017, 9:09 PM

This breaks MinGW. I'll update soon.

include/algorithm
647 ↗(On Diff #98246)

This change is incorrect too.

include/limits
114 ↗(On Diff #98246)

This is incorrect for MinGW.

bcraig added inline comments.May 9 2017, 9:12 AM
include/__config
232–235 ↗(On Diff #98246)

I can see this helping when we are build libc++, but I don't think it helps client apps. They could have included windows.h before including our headers.

Don't get me wrong, I dislike the min and max macros, and bear no hard feelings towards people that define this project wide on the command line, I'm just not sure it will get things done right here.

In the past, I've just surrounded my min and max declarations with parenthesis to suppress macro expansion.

compnerd requested changes to this revision.May 9 2017, 4:33 PM
compnerd added inline comments.
include/__config
232–235 ↗(On Diff #98246)

Yeah, I don't think that this should be defined in __config. Can we do something like #pragma push_macro and #pragma pop_macro in the necessary files?

include/stdio.h
113–118 ↗(On Diff #98246)

Should this be hoisted above the #ifdef __cplusplus? This seems like it should be defined by stdio.h but isn't in msvcrt?

include/support/win32/locale_win32.h
24 ↗(On Diff #98246)

Can you please clang-format this block?

include/support/win32/msvc_builtin_support.h
33–51 ↗(On Diff #98246)

I think I prefer the following implementation:

_LIBCPP_ALWAYS_INLINE int __builtin_popcount(unsigned int value) {
  return __popcnt(value);
}
58–76 ↗(On Diff #98246)

I think I prefer the following implementation:

_LIBCPP_ALWAYS_INLINE int __builtin_popcountll(unsigned long long value) {
  return __popcnt64(value);
}
src/string.cpp
430 ↗(On Diff #98246)

This seems scary. Why do we need to cast the function?

majnemer added a subscriber: majnemer.May 9 2017, 4:49 PM
majnemer added inline comments.
include/support/win32/msvc_builtin_support.h
33 ↗(On Diff #98246)

I think it'd be better not to call it __builtin_anything. MSVC uses the __builtin_ namespace too, see https://godbolt.org/g/HwMskX

Maybe create a wrapper called __libcpp_popcount?

EricWF added inline comments.May 9 2017, 5:32 PM
include/__config
232–235 ↗(On Diff #98246)

Alright I'll remove the NOMINMAX define in __config and start to sprinkle the __undef_min_max include where it's currently needed.

@compnerd, using push_macro and pop_macro are going to be the correct way to handle this, but that's a change for another patch.

include/support/win32/msvc_builtin_support.h
33 ↗(On Diff #98246)

That's a change for another patch, one that's just meant to restructure the headers.

This patch simply moves this code to another file.

33–51 ↗(On Diff #98246)

That's a change for another patch, one that's just meant to restructure the headers.

This patch simply moves this code to another file.

src/string.cpp
430 ↗(On Diff #98246)

No idea.

EricWF updated this revision to Diff 98528.May 10 2017, 1:48 PM
EricWF edited edge metadata.
  • General cleanup changes.

Libc++ trunk currently doesn't build under MinGW, so I'm not concerned about breaking that worse with this patch. I've set up a Appveyor builder to track MinGW so we can get it green later.

Also I'm planning on making all of the the changes suggested in inline comments, but in a follow up patch. I would like to keep this to simply renaming and restructuring include files.
With that in mind does anybody object to landing this?

bcraig edited edge metadata.May 10 2017, 1:56 PM

LGTM

EricWF accepted this revision.May 10 2017, 2:09 PM

@compnerd I'm going to go ahead and land this and then submit a separate review for the changes you've requested. I hope you don't mind :-)

Closed by commit rL302727: [libc++] Refactor Windows support headers. (authored by EricWF). · Explain WhyMay 10 2017, 2:11 PM
This revision was automatically updated to reflect the committed changes.
EricWF mentioned this in rL302731: Don't interfere with the __builtin_foo namespace under MSVC.May 10 2017, 2:43 PM

Revision Contents

PathSize
libcxx/
trunk/
include/
1 line
1 line
4 lines
9 lines
4 lines
5 lines
4 lines
support/
win32/
72 lines
79 lines
33 lines
32 lines
156 lines
177 lines
9 lines
src/
5 lines
support/
runtime/
1 line

Diff 98530

libcxx/trunk/include/__mutex_base

Show All 9 Lines
#ifndef _LIBCPP___MUTEX_BASE #ifndef _LIBCPP___MUTEX_BASE
#define _LIBCPP___MUTEX_BASE #define _LIBCPP___MUTEX_BASE
#include <__config> #include <__config>
#include <chrono> #include <chrono>
#include <system_error> #include <system_error>
#include <__threading_support> #include <__threading_support>
#include <__undef_min_max>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#ifndef _LIBCPP_HAS_NO_THREADS #ifndef _LIBCPP_HAS_NO_THREADS
▲ Show 20 Lines • Show All 405 Lines • Show Last 20 Lines

libcxx/trunk/include/__threading_support

Show All 24 Lines
#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD) #if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
# include <pthread.h> # include <pthread.h>
# include <sched.h> # include <sched.h>
#elif defined(_LIBCPP_HAS_THREAD_API_WIN32) #elif defined(_LIBCPP_HAS_THREAD_API_WIN32)
#include <Windows.h> #include <Windows.h>
#include <process.h> #include <process.h>
#include <fibersapi.h> #include <fibersapi.h>
#include <__undef_min_max>
#endif #endif
#if defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) || \ #if defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) || \
defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL) defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL)
#define _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_FUNC_VIS #define _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_FUNC_VIS
#else #else
#define _LIBCPP_THREAD_ABI_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY #define _LIBCPP_THREAD_ABI_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
#endif #endif
▲ Show 20 Lines • Show All 593 Lines • Show Last 20 Lines

libcxx/trunk/include/algorithm

Show First 20 Lines • Show All 638 Lines • ▼ Show 20 Lines
#include <utility> // needed to provide swap_ranges. #include <utility> // needed to provide swap_ranges.
#include <memory> #include <memory>
#include <iterator> #include <iterator>
#include <cstddef> #include <cstddef>
#if defined(__IBMCPP__) #if defined(__IBMCPP__)
#include "support/ibm/support.h" #include "support/ibm/support.h"
#endif #endif
#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__) #if defined(_LIBCPP_COMPILER_MSVC)
#include "support/win32/support.h" #include "support/win32/msvc_builtin_support.h"
#endif #endif
#include <__undef_min_max> #include <__undef_min_max>
#include <__debug> #include <__debug>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
▲ Show 20 Lines • Show All 5,147 Lines • Show Last 20 Lines

libcxx/trunk/include/ctype.h

Show All 34 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
#include_next <ctype.h> #include_next <ctype.h>
#ifdef __cplusplus #ifdef __cplusplus
#if defined(_LIBCPP_MSVCRT)
// We support including .h headers inside 'extern "C"' contexts, so switch
// back to C++ linkage before including these C++ headers.
extern "C++" {
#include "support/win32/support.h"
#include "support/win32/locale_win32.h"
}
#endif // _LIBCPP_MSVCRT
#undef isalnum #undef isalnum
#undef isalpha #undef isalpha
#undef isblank #undef isblank
#undef iscntrl #undef iscntrl
#undef isdigit #undef isdigit
#undef isgraph #undef isgraph
#undef islower #undef islower
#undef isprint #undef isprint
Show All 10 Lines

libcxx/trunk/include/limits

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
#include <type_traits> #include <type_traits>
#include <__undef_min_max> #include <__undef_min_max>
#if defined(_LIBCPP_MSVCRT) #if defined(_LIBCPP_COMPILER_MSVC)
#include "support/win32/limits_win32.h" #include "support/win32/limits_msvc_win32.h"
#endif // _LIBCPP_MSVCRT #endif // _LIBCPP_MSVCRT
#if defined(__IBMCPP__) #if defined(__IBMCPP__)
#include "support/ibm/limits.h" #include "support/ibm/limits.h"
#endif // __IBMCPP__ #endif // __IBMCPP__
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
▲ Show 20 Lines • Show All 691 Lines • Show Last 20 Lines

libcxx/trunk/include/stdio.h

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Lines
#endif #endif
#include_next <stdio.h> #include_next <stdio.h>
#ifdef __cplusplus #ifdef __cplusplus
// snprintf // snprintf
#if defined(_LIBCPP_MSVCRT) #if defined(_LIBCPP_MSVCRT)
extern "C++" { extern "C" {
#include "support/win32/support.h" int vasprintf(char **sptr, const char *__restrict fmt, va_list ap);
int asprintf(char **sptr, const char *__restrict fmt, ...);
} }
#endif #endif
#undef getc #undef getc
#undef putc #undef putc
#undef clearerr #undef clearerr
#undef feof #undef feof
#undef ferror #undef ferror
#endif #endif
#endif // _LIBCPP_STDIO_H #endif // _LIBCPP_STDIO_H

libcxx/trunk/include/stdlib.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
#endif #endif
#include_next <stdlib.h> #include_next <stdlib.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C++" { extern "C++" {
#ifdef _LIBCPP_MSVCRT
#include "support/win32/locale_win32.h"
#endif // _LIBCPP_MSVCRT
#undef abs #undef abs
#undef div #undef div
#undef labs #undef labs
#undef ldiv #undef ldiv
#ifndef _LIBCPP_HAS_NO_LONG_LONG #ifndef _LIBCPP_HAS_NO_LONG_LONG
#undef llabs #undef llabs
#undef lldiv #undef lldiv
#endif #endif
Show All 19 Lines

libcxx/trunk/include/support/win32/limits_msvc_win32.h

// -*- C++ -*-
//===------------------ support/win32/limits_msvc_win32.h -----------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_SUPPORT_WIN32_LIMITS_MSVC_WIN32_H
#define _LIBCPP_SUPPORT_WIN32_LIMITS_MSVC_WIN32_H
#if !defined(_LIBCPP_MSVCRT)
#error "This header complements the Microsoft C Runtime library, and should not be included otherwise."
#endif
#if defined(__clang__)
#error "This header should only be included when using Microsofts C1XX frontend"
#endif
#include <limits.h> // CHAR_BIT
#include <float.h> // limit constants
#include <math.h> // HUGE_VAL
#include <ymath.h> // internal MSVC header providing the needed functionality
#define __CHAR_BIT__ CHAR_BIT
#define __FLT_MANT_DIG__ FLT_MANT_DIG
#define __FLT_DIG__ FLT_DIG
#define __FLT_RADIX__ FLT_RADIX
#define __FLT_MIN_EXP__ FLT_MIN_EXP
#define __FLT_MIN_10_EXP__ FLT_MIN_10_EXP
#define __FLT_MAX_EXP__ FLT_MAX_EXP
#define __FLT_MAX_10_EXP__ FLT_MAX_10_EXP
#define __FLT_MIN__ FLT_MIN
#define __FLT_MAX__ FLT_MAX
#define __FLT_EPSILON__ FLT_EPSILON
// predefined by MinGW GCC
#define __FLT_DENORM_MIN__ 1.40129846432481707092e-45F
#define __DBL_MANT_DIG__ DBL_MANT_DIG
#define __DBL_DIG__ DBL_DIG
#define __DBL_RADIX__ DBL_RADIX
#define __DBL_MIN_EXP__ DBL_MIN_EXP
#define __DBL_MIN_10_EXP__ DBL_MIN_10_EXP
#define __DBL_MAX_EXP__ DBL_MAX_EXP
#define __DBL_MAX_10_EXP__ DBL_MAX_10_EXP
#define __DBL_MIN__ DBL_MIN
#define __DBL_MAX__ DBL_MAX
#define __DBL_EPSILON__ DBL_EPSILON
// predefined by MinGW GCC
#define __DBL_DENORM_MIN__ double(4.94065645841246544177e-324L)
#define __LDBL_MANT_DIG__ LDBL_MANT_DIG
#define __LDBL_DIG__ LDBL_DIG
#define __LDBL_RADIX__ LDBL_RADIX
#define __LDBL_MIN_EXP__ LDBL_MIN_EXP
#define __LDBL_MIN_10_EXP__ LDBL_MIN_10_EXP
#define __LDBL_MAX_EXP__ LDBL_MAX_EXP
#define __LDBL_MAX_10_EXP__ LDBL_MAX_10_EXP
#define __LDBL_MIN__ LDBL_MIN
#define __LDBL_MAX__ LDBL_MAX
#define __LDBL_EPSILON__ LDBL_EPSILON
// predefined by MinGW GCC
#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L
// __builtin replacements/workarounds
#define __builtin_huge_vall() _LInf._Long_double
#define __builtin_nanl(__dummmy) _LNan._Long_double
#define __builtin_nansl(__dummy) _LSnan._Long_double
#endif // _LIBCPP_SUPPORT_WIN32_LIMITS_MSVC_WIN32_H

libcxx/trunk/include/support/win32/limits_win32.h

// -*- C++ -*-
//===--------------------- support/win32/limits_win32.h -------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_SUPPORT_WIN32_LIMITS_WIN32_H
#define _LIBCPP_SUPPORT_WIN32_LIMITS_WIN32_H
#if !defined(_LIBCPP_MSVCRT)
#error "This header complements the Microsoft C Runtime library, and should not be included otherwise."
#else
#include <limits.h> // CHAR_BIT
#include <float.h> // limit constants
#if ! defined(__clang__)
#define __CHAR_BIT__ CHAR_BIT
#define __FLT_MANT_DIG__ FLT_MANT_DIG
#define __FLT_DIG__ FLT_DIG
#define __FLT_RADIX__ FLT_RADIX
#define __FLT_MIN_EXP__ FLT_MIN_EXP
#define __FLT_MIN_10_EXP__ FLT_MIN_10_EXP
#define __FLT_MAX_EXP__ FLT_MAX_EXP
#define __FLT_MAX_10_EXP__ FLT_MAX_10_EXP
#define __FLT_MIN__ FLT_MIN
#define __FLT_MAX__ FLT_MAX
#define __FLT_EPSILON__ FLT_EPSILON
// predefined by MinGW GCC
#define __FLT_DENORM_MIN__ 1.40129846432481707092e-45F
#define __DBL_MANT_DIG__ DBL_MANT_DIG
#define __DBL_DIG__ DBL_DIG
#define __DBL_RADIX__ DBL_RADIX
#define __DBL_MIN_EXP__ DBL_MIN_EXP
#define __DBL_MIN_10_EXP__ DBL_MIN_10_EXP
#define __DBL_MAX_EXP__ DBL_MAX_EXP
#define __DBL_MAX_10_EXP__ DBL_MAX_10_EXP
#define __DBL_MIN__ DBL_MIN
#define __DBL_MAX__ DBL_MAX
#define __DBL_EPSILON__ DBL_EPSILON
// predefined by MinGW GCC
#define __DBL_DENORM_MIN__ double(4.94065645841246544177e-324L)
#define __LDBL_MANT_DIG__ LDBL_MANT_DIG
#define __LDBL_DIG__ LDBL_DIG
#define __LDBL_RADIX__ LDBL_RADIX
#define __LDBL_MIN_EXP__ LDBL_MIN_EXP
#define __LDBL_MIN_10_EXP__ LDBL_MIN_10_EXP
#define __LDBL_MAX_EXP__ LDBL_MAX_EXP
#define __LDBL_MAX_10_EXP__ LDBL_MAX_10_EXP
#define __LDBL_MIN__ LDBL_MIN
#define __LDBL_MAX__ LDBL_MAX
#define __LDBL_EPSILON__ LDBL_EPSILON
// predefined by MinGW GCC
#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L
// __builtin replacements/workarounds
#include <math.h> // HUGE_VAL
#include <ymath.h> // internal MSVC header providing the needed functionality
#define __builtin_huge_val() HUGE_VAL
#define __builtin_huge_valf() _FInf._Float
#define __builtin_huge_vall() _LInf._Long_double
#define __builtin_nan(__dummy) _Nan._Double
#define __builtin_nanf(__dummy) _FNan._Float
#define __builtin_nanl(__dummmy) _LNan._Long_double
#define __builtin_nans(__dummy) _Snan._Double
#define __builtin_nansf(__dummy) _FSnan._Float
#define __builtin_nansl(__dummy) _LSnan._Long_double
#endif // ! defined(__clang__)
#endif // _LIBCPP_MSVCRT
#endif // _LIBCPP_SUPPORT_WIN32_LIMITS_WIN32_H

libcxx/trunk/include/support/win32/locale_mgmt_win32.h

// -*- C++ -*-
//===----------------- support/win32/locale_mgmt_win32.h ------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_SUPPORT_WIN32_LOCALE_MGMT_WIN32_H
#define _LIBCPP_SUPPORT_WIN32_LOCALE_MGMT_WIN32_H
#include <xlocinfo.h> // _locale_t
#define locale_t _locale_t
#define LC_COLLATE_MASK _M_COLLATE
#define LC_CTYPE_MASK _M_CTYPE
#define LC_MONETARY_MASK _M_MONETARY
#define LC_NUMERIC_MASK _M_NUMERIC
#define LC_TIME_MASK _M_TIME
#define LC_MESSAGES_MASK _M_MESSAGES
#define LC_ALL_MASK ( LC_COLLATE_MASK \
| LC_CTYPE_MASK \
| LC_MESSAGES_MASK \
| LC_MONETARY_MASK \
| LC_NUMERIC_MASK \
| LC_TIME_MASK )
#define freelocale _free_locale
// FIXME: base currently unused. Needs manual work to construct the new locale
locale_t newlocale( int mask, const char * locale, locale_t base );
locale_t uselocale( locale_t newloc );
#endif // _LIBCPP_SUPPORT_WIN32_LOCALE_MGMT_WIN32_H

libcxx/trunk/include/support/win32/locale_win32.h

// -*- C++ -*- // -*- C++ -*-
//===--------------------- support/win32/locale_win32.h -------------------===// //===--------------------- support/win32/locale_win32.h -------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H #ifndef _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H
#define _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H #define _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H
#include <__config> #include <__config>
#include "support/win32/support.h"
#include "support/win32/locale_mgmt_win32.h"
#include <stdio.h> #include <stdio.h>
#include <xlocinfo.h> // _locale_t
#define LC_COLLATE_MASK _M_COLLATE
#define LC_CTYPE_MASK _M_CTYPE
#define LC_MONETARY_MASK _M_MONETARY
#define LC_NUMERIC_MASK _M_NUMERIC
#define LC_TIME_MASK _M_TIME
#define LC_MESSAGES_MASK _M_MESSAGES
#define LC_ALL_MASK ( LC_COLLATE_MASK \
| LC_CTYPE_MASK \
| LC_MESSAGES_MASK \
| LC_MONETARY_MASK \
| LC_NUMERIC_MASK \
| LC_TIME_MASK )
#define locale_t _locale_t
// Locale management functions
#define freelocale _free_locale
// FIXME: base currently unused. Needs manual work to construct the new locale
locale_t newlocale( int mask, const char * locale, locale_t base );
locale_t uselocale( locale_t newloc );
lconv *localeconv_l( locale_t loc ); lconv *localeconv_l( locale_t loc );
size_t mbrlen_l( const char *__restrict s, size_t n, size_t mbrlen_l( const char *__restrict s, size_t n,
mbstate_t *__restrict ps, locale_t loc); mbstate_t *__restrict ps, locale_t loc);
size_t mbsrtowcs_l( wchar_t *__restrict dst, const char **__restrict src, size_t mbsrtowcs_l( wchar_t *__restrict dst, const char **__restrict src,
size_t len, mbstate_t *__restrict ps, locale_t loc ); size_t len, mbstate_t *__restrict ps, locale_t loc );
size_t wcrtomb_l( char *__restrict s, wchar_t wc, mbstate_t *__restrict ps, size_t wcrtomb_l( char *__restrict s, wchar_t wc, mbstate_t *__restrict ps,
locale_t loc); locale_t loc);
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
#define vsscanf_l( __s, __l, __f, ...) _sscanf_l( __s, __f, __l, __VA_ARGS__ ) #define vsscanf_l( __s, __l, __f, ...) _sscanf_l( __s, __f, __l, __VA_ARGS__ )
#define sprintf_l( __s, __l, __f, ... ) _sprintf_l( __s, __f, __l, __VA_ARGS__ ) #define sprintf_l( __s, __l, __f, ... ) _sprintf_l( __s, __f, __l, __VA_ARGS__ )
#define vsprintf_l( __s, __l, __f, ... ) _vsprintf_l( __s, __f, __l, __VA_ARGS__ ) #define vsprintf_l( __s, __l, __f, ... ) _vsprintf_l( __s, __f, __l, __VA_ARGS__ )
#define vsnprintf_l( __s, __n, __l, __f, ... ) _vsnprintf_l( __s, __n, __f, __l, __VA_ARGS__ ) #define vsnprintf_l( __s, __n, __l, __f, ... ) _vsnprintf_l( __s, __n, __f, __l, __VA_ARGS__ )
_LIBCPP_FUNC_VIS int snprintf_l(char *ret, size_t n, locale_t loc, const char *format, ...); _LIBCPP_FUNC_VIS int snprintf_l(char *ret, size_t n, locale_t loc, const char *format, ...);
_LIBCPP_FUNC_VIS int asprintf_l( char **ret, locale_t loc, const char *format, ... ); _LIBCPP_FUNC_VIS int asprintf_l( char **ret, locale_t loc, const char *format, ... );
_LIBCPP_FUNC_VIS int vasprintf_l( char **ret, locale_t loc, const char *format, va_list ap ); _LIBCPP_FUNC_VIS int vasprintf_l( char **ret, locale_t loc, const char *format, va_list ap );
// not-so-pressing FIXME: use locale to determine blank characters // not-so-pressing FIXME: use locale to determine blank characters
inline int isblank_l( int c, locale_t /*loc*/ ) inline int isblank_l( int c, locale_t /*loc*/ )
{ {
return ( c == ' ' || c == '\t' ); return ( c == ' ' || c == '\t' );
} }
inline int iswblank_l( wint_t c, locale_t /*loc*/ ) inline int iswblank_l( wint_t c, locale_t /*loc*/ )
{ {
return ( c == L' ' || c == L'\t' ); return ( c == L' ' || c == L'\t' );
} }
#if defined(_LIBCPP_MSVCRT)
inline int isblank( int c, locale_t /*loc*/ )
{ return ( c == ' ' || c == '\t' ); }
inline int iswblank( wint_t c, locale_t /*loc*/ )
{ return ( c == L' ' || c == L'\t' ); }
#endif // _LIBCPP_MSVCRT
#endif // _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H #endif // _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H

libcxx/trunk/include/support/win32/msvc_builtin_support.h

// -*- C++ -*-
//===----------------------- support/win32/support.h ----------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_SUPPORT_WIN32_MSVC_BUILTIN_SUPPORT_H
#define _LIBCPP_SUPPORT_WIN32_MSVC_BUILTIN_SUPPORT_H
#ifndef _LIBCPP_COMPILER_MSVC
#error "This header can only be included when using Microsoft's C1XX frontend"
#endif
#ifndef NOMINMAX
#define NOMINMAX
#endif
// "builtins" not implemented here for Clang or GCC as they provide
// implementations. Assuming required for elsewhere else, certainly MSVC.
#include <intrin.h>
// Bit builtin's make these assumptions when calling _BitScanForward/Reverse
// etc. These assumptions are expected to be true for Win32/Win64 which this
// file supports.
static_assert(sizeof(unsigned long long) == 8, "");
static_assert(sizeof(unsigned long) == 4, "");
static_assert(sizeof(unsigned int) == 4, "");
_LIBCPP_ALWAYS_INLINE int __builtin_popcount(unsigned int x)
{
// Binary: 0101...
static const unsigned int m1 = 0x55555555;
// Binary: 00110011..
static const unsigned int m2 = 0x33333333;
// Binary: 4 zeros, 4 ones ...
static const unsigned int m4 = 0x0f0f0f0f;
// The sum of 256 to the power of 0,1,2,3...
static const unsigned int h01 = 0x01010101;
// Put count of each 2 bits into those 2 bits.
x -= (x >> 1) & m1;
// Put count of each 4 bits into those 4 bits.
x = (x & m2) + ((x >> 2) & m2);
// Put count of each 8 bits into those 8 bits.
x = (x + (x >> 4)) & m4;
// Returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24).
return (x * h01) >> 24;
}
_LIBCPP_ALWAYS_INLINE int __builtin_popcountl(unsigned long x)
{
return __builtin_popcount(static_cast<int>(x));
}
_LIBCPP_ALWAYS_INLINE int __builtin_popcountll(unsigned long long x)
{
// Binary: 0101...
static const unsigned long long m1 = 0x5555555555555555;
// Binary: 00110011..
static const unsigned long long m2 = 0x3333333333333333;
// Binary: 4 zeros, 4 ones ...
static const unsigned long long m4 = 0x0f0f0f0f0f0f0f0f;
// The sum of 256 to the power of 0,1,2,3...
static const unsigned long long h01 = 0x0101010101010101;
// Put count of each 2 bits into those 2 bits.
x -= (x >> 1) & m1;
// Put count of each 4 bits into those 4 bits.
x = (x & m2) + ((x >> 2) & m2);
// Put count of each 8 bits into those 8 bits.
x = (x + (x >> 4)) & m4;
// Returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ...
return static_cast<int>((x * h01) >> 56);
}
// Returns the number of trailing 0-bits in x, starting at the least significant
// bit position. If x is 0, the result is undefined.
_LIBCPP_ALWAYS_INLINE int __builtin_ctzll(unsigned long long mask)
{
unsigned long where;
// Search from LSB to MSB for first set bit.
// Returns zero if no set bit is found.
#if defined(_LIBCPP_HAS_BITSCAN64)
(defined(_M_AMD64) || defined(__x86_64__))
if (_BitScanForward64(&where, mask))
return static_cast<int>(where);
#else
// Win32 doesn't have _BitScanForward64 so emulate it with two 32 bit calls.
// Scan the Low Word.
if (_BitScanForward(&where, static_cast<unsigned long>(mask)))
return static_cast<int>(where);
// Scan the High Word.
if (_BitScanForward(&where, static_cast<unsigned long>(mask >> 32)))
return static_cast<int>(where + 32); // Create a bit offset from the LSB.
#endif
return 64;
}
_LIBCPP_ALWAYS_INLINE int __builtin_ctzl(unsigned long mask)
{
unsigned long where;
// Search from LSB to MSB for first set bit.
// Returns zero if no set bit is found.
if (_BitScanForward(&where, mask))
return static_cast<int>(where);
return 32;
}
_LIBCPP_ALWAYS_INLINE int __builtin_ctz(unsigned int mask)
{
// Win32 and Win64 expectations.
static_assert(sizeof(mask) == 4, "");
static_assert(sizeof(unsigned long) == 4, "");
return __builtin_ctzl(static_cast<unsigned long>(mask));
}
// Returns the number of leading 0-bits in x, starting at the most significant
// bit position. If x is 0, the result is undefined.
_LIBCPP_ALWAYS_INLINE int __builtin_clzll(unsigned long long mask)
{
unsigned long where;
// BitScanReverse scans from MSB to LSB for first set bit.
// Returns 0 if no set bit is found.
#if defined(_LIBCPP_HAS_BITSCAN64)
if (_BitScanReverse64(&where, mask))
return static_cast<int>(63 - where);
#else
// Scan the high 32 bits.
if (_BitScanReverse(&where, static_cast<unsigned long>(mask >> 32)))
return static_cast<int>(63 -
(where + 32)); // Create a bit offset from the MSB.
// Scan the low 32 bits.
if (_BitScanReverse(&where, static_cast<unsigned long>(mask)))
return static_cast<int>(63 - where);
#endif
return 64; // Undefined Behavior.
}
_LIBCPP_ALWAYS_INLINE int __builtin_clzl(unsigned long mask)
{
unsigned long where;
// Search from LSB to MSB for first set bit.
// Returns zero if no set bit is found.
if (_BitScanReverse(&where, mask))
return static_cast<int>(31 - where);
return 32; // Undefined Behavior.
}
_LIBCPP_ALWAYS_INLINE int __builtin_clz(unsigned int x)
{
return __builtin_clzl(x);
}
#endif // _LIBCPP_SUPPORT_WIN32_MSVC_BUILTIN_SUPPORT_H

libcxx/trunk/include/support/win32/support.h

// -*- C++ -*-
//===----------------------- support/win32/support.h ----------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_SUPPORT_WIN32_SUPPORT_H
#define _LIBCPP_SUPPORT_WIN32_SUPPORT_H
// Functions and constants used in libc++ that
// are missing from the Windows C library.
#include <wchar.h> // mbstate_t
#include <cstdarg> // va_ macros
// "builtins" not implemented here for Clang or GCC as they provide
// implementations. Assuming required for elsewhere else, certainly MSVC.
#if defined(_LIBCPP_COMPILER_MSVC)
#include <intrin.h>
#endif
#define swprintf _snwprintf
#define vswprintf _vsnwprintf
#ifndef NOMINMAX
#define NOMINMAX
#endif
// The mingw headers already define these as static.
#ifndef __MINGW32__
extern "C" {
int vasprintf(char **sptr, const char *__restrict fmt, va_list ap);
int asprintf(char **sptr, const char *__restrict fmt, ...);
size_t mbsnrtowcs(wchar_t *__restrict dst, const char **__restrict src,
size_t nmc, size_t len, mbstate_t *__restrict ps);
size_t wcsnrtombs(char *__restrict dst, const wchar_t **__restrict src,
size_t nwc, size_t len, mbstate_t *__restrict ps);
}
#endif // __MINGW32__
#if defined(_LIBCPP_COMPILER_MSVC)
// Bit builtin's make these assumptions when calling _BitScanForward/Reverse
// etc. These assumptions are expected to be true for Win32/Win64 which this
// file supports.
static_assert(sizeof(unsigned long long) == 8, "");
static_assert(sizeof(unsigned long) == 4, "");
static_assert(sizeof(unsigned int) == 4, "");
_LIBCPP_ALWAYS_INLINE int __builtin_popcount(unsigned int x)
{
// Binary: 0101...
static const unsigned int m1 = 0x55555555;
// Binary: 00110011..
static const unsigned int m2 = 0x33333333;
// Binary: 4 zeros, 4 ones ...
static const unsigned int m4 = 0x0f0f0f0f;
// The sum of 256 to the power of 0,1,2,3...
static const unsigned int h01 = 0x01010101;
// Put count of each 2 bits into those 2 bits.
x -= (x >> 1) & m1;
// Put count of each 4 bits into those 4 bits.
x = (x & m2) + ((x >> 2) & m2);
// Put count of each 8 bits into those 8 bits.
x = (x + (x >> 4)) & m4;
// Returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24).
return (x * h01) >> 24;
}
_LIBCPP_ALWAYS_INLINE int __builtin_popcountl(unsigned long x)
{
return __builtin_popcount(static_cast<int>(x));
}
_LIBCPP_ALWAYS_INLINE int __builtin_popcountll(unsigned long long x)
{
// Binary: 0101...
static const unsigned long long m1 = 0x5555555555555555;
// Binary: 00110011..
static const unsigned long long m2 = 0x3333333333333333;
// Binary: 4 zeros, 4 ones ...
static const unsigned long long m4 = 0x0f0f0f0f0f0f0f0f;
// The sum of 256 to the power of 0,1,2,3...
static const unsigned long long h01 = 0x0101010101010101;
// Put count of each 2 bits into those 2 bits.
x -= (x >> 1) & m1;
// Put count of each 4 bits into those 4 bits.
x = (x & m2) + ((x >> 2) & m2);
// Put count of each 8 bits into those 8 bits.
x = (x + (x >> 4)) & m4;
// Returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ...
return static_cast<int>((x * h01) >> 56);
}
// Returns the number of trailing 0-bits in x, starting at the least significant
// bit position. If x is 0, the result is undefined.
_LIBCPP_ALWAYS_INLINE int __builtin_ctzll(unsigned long long mask)
{
unsigned long where;
// Search from LSB to MSB for first set bit.
// Returns zero if no set bit is found.
#if defined(_LIBCPP_HAS_BITSCAN64)
(defined(_M_AMD64) || defined(__x86_64__))
if (_BitScanForward64(&where, mask))
return static_cast<int>(where);
#else
// Win32 doesn't have _BitScanForward64 so emulate it with two 32 bit calls.
// Scan the Low Word.
if (_BitScanForward(&where, static_cast<unsigned long>(mask)))
return static_cast<int>(where);
// Scan the High Word.
if (_BitScanForward(&where, static_cast<unsigned long>(mask >> 32)))
return static_cast<int>(where + 32); // Create a bit offset from the LSB.
#endif
return 64;
}
_LIBCPP_ALWAYS_INLINE int __builtin_ctzl(unsigned long mask)
{
unsigned long where;
// Search from LSB to MSB for first set bit.
// Returns zero if no set bit is found.
if (_BitScanForward(&where, mask))
return static_cast<int>(where);
return 32;
}
_LIBCPP_ALWAYS_INLINE int __builtin_ctz(unsigned int mask)
{
// Win32 and Win64 expectations.
static_assert(sizeof(mask) == 4, "");
static_assert(sizeof(unsigned long) == 4, "");
return __builtin_ctzl(static_cast<unsigned long>(mask));
}
// Returns the number of leading 0-bits in x, starting at the most significant
// bit position. If x is 0, the result is undefined.
_LIBCPP_ALWAYS_INLINE int __builtin_clzll(unsigned long long mask)
{
unsigned long where;
// BitScanReverse scans from MSB to LSB for first set bit.
// Returns 0 if no set bit is found.
#if defined(_LIBCPP_HAS_BITSCAN64)
if (_BitScanReverse64(&where, mask))
return static_cast<int>(63 - where);
#else
// Scan the high 32 bits.
if (_BitScanReverse(&where, static_cast<unsigned long>(mask >> 32)))
return static_cast<int>(63 -
(where + 32)); // Create a bit offset from the MSB.
// Scan the low 32 bits.
if (_BitScanReverse(&where, static_cast<unsigned long>(mask)))
return static_cast<int>(63 - where);
#endif
return 64; // Undefined Behavior.
}
_LIBCPP_ALWAYS_INLINE int __builtin_clzl(unsigned long mask)
{
unsigned long where;
// Search from LSB to MSB for first set bit.
// Returns zero if no set bit is found.
if (_BitScanReverse(&where, mask))
return static_cast<int>(31 - where);
return 32; // Undefined Behavior.
}
_LIBCPP_ALWAYS_INLINE int __builtin_clz(unsigned int x)
{
return __builtin_clzl(x);
}
#endif // _LIBCPP_MSVC
#endif // _LIBCPP_SUPPORT_WIN32_SUPPORT_H

libcxx/trunk/include/wchar.h

Show First 20 Lines • Show All 160 Lines • ▼ Show 20 Lines
wchar_t* __libcpp_wmemchr(const wchar_t* __s, wchar_t __c, size_t __n) {return (wchar_t*)wmemchr(__s, __c, __n);} wchar_t* __libcpp_wmemchr(const wchar_t* __s, wchar_t __c, size_t __n) {return (wchar_t*)wmemchr(__s, __c, __n);}
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
const wchar_t* wmemchr(const wchar_t* __s, wchar_t __c, size_t __n) {return __libcpp_wmemchr(__s, __c, __n);} const wchar_t* wmemchr(const wchar_t* __s, wchar_t __c, size_t __n) {return __libcpp_wmemchr(__s, __c, __n);}
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
wchar_t* wmemchr( wchar_t* __s, wchar_t __c, size_t __n) {return __libcpp_wmemchr(__s, __c, __n);} wchar_t* wmemchr( wchar_t* __s, wchar_t __c, size_t __n) {return __libcpp_wmemchr(__s, __c, __n);}
} }
#endif #endif
#if defined(__cplusplus) && (defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)) #if defined(__cplusplus) && defined(_LIBCPP_MSVCRT)
extern "C++" { extern "C" {
#include <support/win32/support.h> // pull in *swprintf defines size_t mbsnrtowcs(wchar_t *__restrict dst, const char **__restrict src,
size_t nmc, size_t len, mbstate_t *__restrict ps);
size_t wcsnrtombs(char *__restrict dst, const wchar_t **__restrict src,
size_t nwc, size_t len, mbstate_t *__restrict ps);
} // extern "C++" } // extern "C++"
#endif // __cplusplus && _LIBCPP_MSVCRT #endif // __cplusplus && _LIBCPP_MSVCRT
#endif // _LIBCPP_WCHAR_H #endif // _LIBCPP_WCHAR_H

libcxx/trunk/src/string.cpp

//===------------------------- string.cpp ---------------------------------===// //===------------------------- string.cpp ---------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "string" #include "string"
#include "cstdlib" #include "cstdlib"
#include "cwchar" #include "cwchar"
#include "cerrno" #include "cerrno"
#include "limits" #include "limits"
#include "stdexcept" #include "stdexcept"
#ifdef _LIBCPP_MSVCRT
#include "support/win32/support.h"
#endif // _LIBCPP_MSVCRT
#include <stdio.h> #include <stdio.h>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __basic_string_common<true>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __basic_string_common<true>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_string<char>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_string<char>;
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_string<wchar_t>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_string<wchar_t>;
▲ Show 20 Lines • Show All 398 Lines • ▼ Show 20 Lines
inline inline
wide_printf wide_printf
get_swprintf() get_swprintf()
{ {
#ifndef _LIBCPP_MSVCRT #ifndef _LIBCPP_MSVCRT
return swprintf; return swprintf;
#else #else
return static_cast<int (__cdecl*)(wchar_t* __restrict, size_t, const wchar_t*__restrict, ...)>(swprintf); return static_cast<int (__cdecl*)(wchar_t* __restrict, size_t, const wchar_t*__restrict, ...)>(_snwprintf);
#endif #endif
} }
} // unnamed namespace } // unnamed namespace
string to_string(int val) string to_string(int val)
{ {
return as_string(snprintf, initial_string<string, int>()(), "%d", val); return as_string(snprintf, initial_string<string, int>()(), "%d", val);
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

libcxx/trunk/src/support/runtime/exception_pointer_msvc.ipp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <yvals.h> // for _CRTIMP2_PURE
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCreate(_Out_ void*); _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCreate(_Out_ void*);
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrDestroy(_Inout_ void*); _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrDestroy(_Inout_ void*);
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopy(_Out_ void*, _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopy(_Out_ void*,
_In_ const void*); _In_ const void*);
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
__ExceptionPtrAssign(_Inout_ void*, _In_ const void*); __ExceptionPtrAssign(_Inout_ void*, _In_ const void*);
_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL _CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines
libcxx/trunk/include/support/win32/msvc_builtin_support.h