Merge llvm, clang, lld, lldb, compiler-rt and libc++ r304460, and update
build glue.
This commit is contained in:
commit
f9448bf33f
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/projects/clang500-import/; revision=319479
@ -32,9 +32,6 @@ extern "C" {
|
||||
// descriptor. Returns -1 on failure, or if coverage dumping is disabled.
|
||||
// This is intended for use by sandboxing code.
|
||||
intptr_t __sanitizer_maybe_open_cov_file(const char *name);
|
||||
// Get the number of unique covered blocks (or edges).
|
||||
// This can be useful for coverage-directed in-process fuzzers.
|
||||
uintptr_t __sanitizer_get_total_unique_coverage();
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
@ -47,8 +47,6 @@ static u32 RZSize2Log(u32 rz_size) {
|
||||
return res;
|
||||
}
|
||||
|
||||
static AsanAllocator &get_allocator();
|
||||
|
||||
// The memory chunk allocated from the underlying allocator looks like this:
|
||||
// L L L L L L H H U U U U U U R R
|
||||
// L -- left redzone words (0 or more bytes)
|
||||
@ -719,7 +717,7 @@ struct Allocator {
|
||||
|
||||
static Allocator instance(LINKER_INITIALIZED);
|
||||
|
||||
static AsanAllocator &get_allocator() {
|
||||
AsanAllocator &get_allocator() {
|
||||
return instance.allocator;
|
||||
}
|
||||
|
||||
|
@ -213,5 +213,7 @@ void asan_mz_force_unlock();
|
||||
void PrintInternalAllocatorStats();
|
||||
void AsanSoftRssLimitExceededCallback(bool exceeded);
|
||||
|
||||
AsanAllocator &get_allocator();
|
||||
|
||||
} // namespace __asan
|
||||
#endif // ASAN_ALLOCATOR_H
|
||||
|
@ -194,6 +194,10 @@ void InitializeFlags() {
|
||||
Report("WARNING: strchr* interceptors are enabled even though "
|
||||
"replace_str=0. Use intercept_strchr=0 to disable them.");
|
||||
}
|
||||
if (!f->replace_str && common_flags()->intercept_strndup) {
|
||||
Report("WARNING: strndup* interceptors are enabled even though "
|
||||
"replace_str=0. Use intercept_strndup=0 to disable them.");
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace __asan
|
||||
|
@ -22,6 +22,7 @@
|
||||
#include "asan_stats.h"
|
||||
#include "asan_suppressions.h"
|
||||
#include "lsan/lsan_common.h"
|
||||
#include "sanitizer_common/sanitizer_stackdepot.h"
|
||||
#include "sanitizer_common/sanitizer_libc.h"
|
||||
|
||||
#if SANITIZER_POSIX
|
||||
@ -705,11 +706,27 @@ INTERCEPTOR(int, __cxa_atexit, void (*func)(void *), void *arg,
|
||||
#endif // ASAN_INTERCEPT___CXA_ATEXIT
|
||||
|
||||
#if ASAN_INTERCEPT_FORK
|
||||
static void BeforeFork() {
|
||||
if (SANITIZER_LINUX) {
|
||||
get_allocator().ForceLock();
|
||||
StackDepotLockAll();
|
||||
}
|
||||
}
|
||||
|
||||
static void AfterFork() {
|
||||
if (SANITIZER_LINUX) {
|
||||
StackDepotUnlockAll();
|
||||
get_allocator().ForceUnlock();
|
||||
}
|
||||
}
|
||||
|
||||
INTERCEPTOR(int, fork, void) {
|
||||
ENSURE_ASAN_INITED();
|
||||
BeforeFork();
|
||||
if (common_flags()->coverage) CovBeforeFork();
|
||||
int pid = REAL(fork)();
|
||||
if (common_flags()->coverage) CovAfterFork(pid);
|
||||
AfterFork();
|
||||
return pid;
|
||||
}
|
||||
#endif // ASAN_INTERCEPT_FORK
|
||||
|
@ -287,8 +287,6 @@ fun:__sanitizer_cov_with_check=uninstrumented
|
||||
fun:__sanitizer_cov_with_check=discard
|
||||
fun:__sanitizer_set_death_callback=uninstrumented
|
||||
fun:__sanitizer_set_death_callback=discard
|
||||
fun:__sanitizer_get_total_unique_coverage=uninstrumented
|
||||
fun:__sanitizer_get_total_unique_coverage=discard
|
||||
fun:__sanitizer_update_counter_bitset_and_clear_counters=uninstrumented
|
||||
fun:__sanitizer_update_counter_bitset_and_clear_counters=discard
|
||||
|
||||
|
@ -22,6 +22,7 @@
|
||||
#include "sanitizer_common/sanitizer_platform_interceptors.h"
|
||||
#include "sanitizer_common/sanitizer_platform_limits_posix.h"
|
||||
#include "sanitizer_common/sanitizer_posix.h"
|
||||
#include "sanitizer_common/sanitizer_stackdepot.h"
|
||||
#include "sanitizer_common/sanitizer_tls_get_addr.h"
|
||||
#include "lsan.h"
|
||||
#include "lsan_allocator.h"
|
||||
@ -97,6 +98,28 @@ INTERCEPTOR(void*, valloc, uptr size) {
|
||||
}
|
||||
#endif
|
||||
|
||||
static void BeforeFork() {
|
||||
if (SANITIZER_LINUX) {
|
||||
LockAllocator();
|
||||
StackDepotLockAll();
|
||||
}
|
||||
}
|
||||
|
||||
static void AfterFork() {
|
||||
if (SANITIZER_LINUX) {
|
||||
StackDepotUnlockAll();
|
||||
UnlockAllocator();
|
||||
}
|
||||
}
|
||||
|
||||
INTERCEPTOR(int, fork, void) {
|
||||
ENSURE_LSAN_INITED;
|
||||
BeforeFork();
|
||||
int pid = REAL(fork)();
|
||||
AfterFork();
|
||||
return pid;
|
||||
}
|
||||
|
||||
#if SANITIZER_INTERCEPT_MEMALIGN
|
||||
INTERCEPTOR(void*, memalign, uptr alignment, uptr size) {
|
||||
ENSURE_LSAN_INITED;
|
||||
@ -336,6 +359,7 @@ void InitializeInterceptors() {
|
||||
LSAN_MAYBE_INTERCEPT_MALLOPT;
|
||||
INTERCEPT_FUNCTION(pthread_create);
|
||||
INTERCEPT_FUNCTION(pthread_join);
|
||||
INTERCEPT_FUNCTION(fork);
|
||||
|
||||
if (pthread_key_create(&g_thread_finalize_key, &thread_finalize)) {
|
||||
Report("LeakSanitizer: failed to create thread key.\n");
|
||||
|
@ -12,8 +12,6 @@
|
||||
// MemorySanitizer allocator.
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "sanitizer_common/sanitizer_allocator.h"
|
||||
#include "sanitizer_common/sanitizer_allocator_interface.h"
|
||||
#include "msan.h"
|
||||
#include "msan_allocator.h"
|
||||
#include "msan_origin.h"
|
||||
@ -22,102 +20,12 @@
|
||||
|
||||
namespace __msan {
|
||||
|
||||
struct Metadata {
|
||||
uptr requested_size;
|
||||
};
|
||||
|
||||
struct MsanMapUnmapCallback {
|
||||
void OnMap(uptr p, uptr size) const {}
|
||||
void OnUnmap(uptr p, uptr size) const {
|
||||
__msan_unpoison((void *)p, size);
|
||||
|
||||
// We are about to unmap a chunk of user memory.
|
||||
// Mark the corresponding shadow memory as not needed.
|
||||
uptr shadow_p = MEM_TO_SHADOW(p);
|
||||
ReleaseMemoryPagesToOS(shadow_p, shadow_p + size);
|
||||
if (__msan_get_track_origins()) {
|
||||
uptr origin_p = MEM_TO_ORIGIN(p);
|
||||
ReleaseMemoryPagesToOS(origin_p, origin_p + size);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#if defined(__mips64)
|
||||
static const uptr kMaxAllowedMallocSize = 2UL << 30;
|
||||
static const uptr kRegionSizeLog = 20;
|
||||
static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
|
||||
typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
|
||||
|
||||
struct AP32 {
|
||||
static const uptr kSpaceBeg = 0;
|
||||
static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
|
||||
static const uptr kMetadataSize = sizeof(Metadata);
|
||||
typedef __sanitizer::CompactSizeClassMap SizeClassMap;
|
||||
static const uptr kRegionSizeLog = __msan::kRegionSizeLog;
|
||||
typedef __msan::ByteMap ByteMap;
|
||||
typedef MsanMapUnmapCallback MapUnmapCallback;
|
||||
static const uptr kFlags = 0;
|
||||
};
|
||||
typedef SizeClassAllocator32<AP32> PrimaryAllocator;
|
||||
#elif defined(__x86_64__)
|
||||
#if SANITIZER_LINUX && !defined(MSAN_LINUX_X86_64_OLD_MAPPING)
|
||||
static const uptr kAllocatorSpace = 0x700000000000ULL;
|
||||
#else
|
||||
static const uptr kAllocatorSpace = 0x600000000000ULL;
|
||||
#endif
|
||||
static const uptr kMaxAllowedMallocSize = 8UL << 30;
|
||||
|
||||
struct AP64 { // Allocator64 parameters. Deliberately using a short name.
|
||||
static const uptr kSpaceBeg = kAllocatorSpace;
|
||||
static const uptr kSpaceSize = 0x40000000000; // 4T.
|
||||
static const uptr kMetadataSize = sizeof(Metadata);
|
||||
typedef DefaultSizeClassMap SizeClassMap;
|
||||
typedef MsanMapUnmapCallback MapUnmapCallback;
|
||||
static const uptr kFlags = 0;
|
||||
};
|
||||
|
||||
typedef SizeClassAllocator64<AP64> PrimaryAllocator;
|
||||
|
||||
#elif defined(__powerpc64__)
|
||||
static const uptr kMaxAllowedMallocSize = 2UL << 30; // 2G
|
||||
|
||||
struct AP64 { // Allocator64 parameters. Deliberately using a short name.
|
||||
static const uptr kSpaceBeg = 0x300000000000;
|
||||
static const uptr kSpaceSize = 0x020000000000; // 2T.
|
||||
static const uptr kMetadataSize = sizeof(Metadata);
|
||||
typedef DefaultSizeClassMap SizeClassMap;
|
||||
typedef MsanMapUnmapCallback MapUnmapCallback;
|
||||
static const uptr kFlags = 0;
|
||||
};
|
||||
|
||||
typedef SizeClassAllocator64<AP64> PrimaryAllocator;
|
||||
#elif defined(__aarch64__)
|
||||
static const uptr kMaxAllowedMallocSize = 2UL << 30; // 2G
|
||||
static const uptr kRegionSizeLog = 20;
|
||||
static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
|
||||
typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
|
||||
|
||||
struct AP32 {
|
||||
static const uptr kSpaceBeg = 0;
|
||||
static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
|
||||
static const uptr kMetadataSize = sizeof(Metadata);
|
||||
typedef __sanitizer::CompactSizeClassMap SizeClassMap;
|
||||
static const uptr kRegionSizeLog = __msan::kRegionSizeLog;
|
||||
typedef __msan::ByteMap ByteMap;
|
||||
typedef MsanMapUnmapCallback MapUnmapCallback;
|
||||
static const uptr kFlags = 0;
|
||||
};
|
||||
typedef SizeClassAllocator32<AP32> PrimaryAllocator;
|
||||
#endif
|
||||
typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
|
||||
typedef LargeMmapAllocator<MsanMapUnmapCallback> SecondaryAllocator;
|
||||
typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
|
||||
SecondaryAllocator> Allocator;
|
||||
|
||||
static Allocator allocator;
|
||||
static AllocatorCache fallback_allocator_cache;
|
||||
static SpinMutex fallback_mutex;
|
||||
|
||||
Allocator &get_allocator() { return allocator; }
|
||||
|
||||
void MsanAllocatorInit() {
|
||||
allocator.Init(
|
||||
common_flags()->allocator_may_return_null,
|
||||
|
@ -15,9 +15,106 @@
|
||||
#define MSAN_ALLOCATOR_H
|
||||
|
||||
#include "sanitizer_common/sanitizer_common.h"
|
||||
#include "sanitizer_common/sanitizer_allocator.h"
|
||||
#include "sanitizer_common/sanitizer_allocator_interface.h"
|
||||
|
||||
namespace __msan {
|
||||
|
||||
struct Metadata {
|
||||
uptr requested_size;
|
||||
};
|
||||
|
||||
struct MsanMapUnmapCallback {
|
||||
void OnMap(uptr p, uptr size) const {}
|
||||
void OnUnmap(uptr p, uptr size) const {
|
||||
__msan_unpoison((void *)p, size);
|
||||
|
||||
// We are about to unmap a chunk of user memory.
|
||||
// Mark the corresponding shadow memory as not needed.
|
||||
uptr shadow_p = MEM_TO_SHADOW(p);
|
||||
ReleaseMemoryPagesToOS(shadow_p, shadow_p + size);
|
||||
if (__msan_get_track_origins()) {
|
||||
uptr origin_p = MEM_TO_ORIGIN(p);
|
||||
ReleaseMemoryPagesToOS(origin_p, origin_p + size);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#if defined(__mips64)
|
||||
static const uptr kMaxAllowedMallocSize = 2UL << 30;
|
||||
static const uptr kRegionSizeLog = 20;
|
||||
static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
|
||||
typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
|
||||
|
||||
struct AP32 {
|
||||
static const uptr kSpaceBeg = 0;
|
||||
static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
|
||||
static const uptr kMetadataSize = sizeof(Metadata);
|
||||
typedef __sanitizer::CompactSizeClassMap SizeClassMap;
|
||||
static const uptr kRegionSizeLog = __msan::kRegionSizeLog;
|
||||
typedef __msan::ByteMap ByteMap;
|
||||
typedef MsanMapUnmapCallback MapUnmapCallback;
|
||||
static const uptr kFlags = 0;
|
||||
};
|
||||
typedef SizeClassAllocator32<AP32> PrimaryAllocator;
|
||||
#elif defined(__x86_64__)
|
||||
#if SANITIZER_LINUX && !defined(MSAN_LINUX_X86_64_OLD_MAPPING)
|
||||
static const uptr kAllocatorSpace = 0x700000000000ULL;
|
||||
#else
|
||||
static const uptr kAllocatorSpace = 0x600000000000ULL;
|
||||
#endif
|
||||
static const uptr kMaxAllowedMallocSize = 8UL << 30;
|
||||
|
||||
struct AP64 { // Allocator64 parameters. Deliberately using a short name.
|
||||
static const uptr kSpaceBeg = kAllocatorSpace;
|
||||
static const uptr kSpaceSize = 0x40000000000; // 4T.
|
||||
static const uptr kMetadataSize = sizeof(Metadata);
|
||||
typedef DefaultSizeClassMap SizeClassMap;
|
||||
typedef MsanMapUnmapCallback MapUnmapCallback;
|
||||
static const uptr kFlags = 0;
|
||||
};
|
||||
|
||||
typedef SizeClassAllocator64<AP64> PrimaryAllocator;
|
||||
|
||||
#elif defined(__powerpc64__)
|
||||
static const uptr kMaxAllowedMallocSize = 2UL << 30; // 2G
|
||||
|
||||
struct AP64 { // Allocator64 parameters. Deliberately using a short name.
|
||||
static const uptr kSpaceBeg = 0x300000000000;
|
||||
static const uptr kSpaceSize = 0x020000000000; // 2T.
|
||||
static const uptr kMetadataSize = sizeof(Metadata);
|
||||
typedef DefaultSizeClassMap SizeClassMap;
|
||||
typedef MsanMapUnmapCallback MapUnmapCallback;
|
||||
static const uptr kFlags = 0;
|
||||
};
|
||||
|
||||
typedef SizeClassAllocator64<AP64> PrimaryAllocator;
|
||||
#elif defined(__aarch64__)
|
||||
static const uptr kMaxAllowedMallocSize = 2UL << 30; // 2G
|
||||
static const uptr kRegionSizeLog = 20;
|
||||
static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
|
||||
typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
|
||||
|
||||
struct AP32 {
|
||||
static const uptr kSpaceBeg = 0;
|
||||
static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
|
||||
static const uptr kMetadataSize = sizeof(Metadata);
|
||||
typedef __sanitizer::CompactSizeClassMap SizeClassMap;
|
||||
static const uptr kRegionSizeLog = __msan::kRegionSizeLog;
|
||||
typedef __msan::ByteMap ByteMap;
|
||||
typedef MsanMapUnmapCallback MapUnmapCallback;
|
||||
static const uptr kFlags = 0;
|
||||
};
|
||||
typedef SizeClassAllocator32<AP32> PrimaryAllocator;
|
||||
#endif
|
||||
typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
|
||||
typedef LargeMmapAllocator<MsanMapUnmapCallback> SecondaryAllocator;
|
||||
typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
|
||||
SecondaryAllocator> Allocator;
|
||||
|
||||
|
||||
Allocator &get_allocator();
|
||||
|
||||
struct MsanThreadLocalMallocStorage {
|
||||
uptr quarantine_cache[16];
|
||||
// Allocator cache contains atomic_uint64_t which must be 8-byte aligned.
|
||||
|
@ -341,33 +341,6 @@ INTERCEPTOR(char *, __strdup, char *src) {
|
||||
#define MSAN_MAYBE_INTERCEPT___STRDUP
|
||||
#endif
|
||||
|
||||
INTERCEPTOR(char *, strndup, char *src, SIZE_T n) {
|
||||
ENSURE_MSAN_INITED();
|
||||
GET_STORE_STACK_TRACE;
|
||||
// On FreeBSD strndup() leverages strnlen().
|
||||
InterceptorScope interceptor_scope;
|
||||
SIZE_T copy_size = REAL(strnlen)(src, n);
|
||||
char *res = REAL(strndup)(src, n);
|
||||
CopyShadowAndOrigin(res, src, copy_size, &stack);
|
||||
__msan_unpoison(res + copy_size, 1); // \0
|
||||
return res;
|
||||
}
|
||||
|
||||
#if !SANITIZER_FREEBSD
|
||||
INTERCEPTOR(char *, __strndup, char *src, SIZE_T n) {
|
||||
ENSURE_MSAN_INITED();
|
||||
GET_STORE_STACK_TRACE;
|
||||
SIZE_T copy_size = REAL(strnlen)(src, n);
|
||||
char *res = REAL(__strndup)(src, n);
|
||||
CopyShadowAndOrigin(res, src, copy_size, &stack);
|
||||
__msan_unpoison(res + copy_size, 1); // \0
|
||||
return res;
|
||||
}
|
||||
#define MSAN_MAYBE_INTERCEPT___STRNDUP INTERCEPT_FUNCTION(__strndup)
|
||||
#else
|
||||
#define MSAN_MAYBE_INTERCEPT___STRNDUP
|
||||
#endif
|
||||
|
||||
INTERCEPTOR(char *, gcvt, double number, SIZE_T ndigit, char *buf) {
|
||||
ENSURE_MSAN_INITED();
|
||||
char *res = REAL(gcvt)(number, ndigit, buf);
|
||||
@ -1228,6 +1201,7 @@ INTERCEPTOR(void *, shmat, int shmid, const void *shmaddr, int shmflg) {
|
||||
}
|
||||
|
||||
static void BeforeFork() {
|
||||
get_allocator().ForceLock();
|
||||
StackDepotLockAll();
|
||||
ChainedOriginDepotLockAll();
|
||||
}
|
||||
@ -1235,6 +1209,7 @@ static void BeforeFork() {
|
||||
static void AfterFork() {
|
||||
ChainedOriginDepotUnlockAll();
|
||||
StackDepotUnlockAll();
|
||||
get_allocator().ForceUnlock();
|
||||
}
|
||||
|
||||
INTERCEPTOR(int, fork, void) {
|
||||
@ -1371,6 +1346,13 @@ int OnExit() {
|
||||
return __msan_memcpy(to, from, size); \
|
||||
}
|
||||
|
||||
#define COMMON_INTERCEPTOR_COPY_STRING(ctx, to, from, size) \
|
||||
do { \
|
||||
GET_STORE_STACK_TRACE; \
|
||||
CopyShadowAndOrigin(to, from, size, &stack); \
|
||||
__msan_unpoison(to + size, 1); \
|
||||
} while (false)
|
||||
|
||||
#include "sanitizer_common/sanitizer_platform_interceptors.h"
|
||||
#include "sanitizer_common/sanitizer_common_interceptors.inc"
|
||||
|
||||
@ -1538,8 +1520,6 @@ void InitializeInterceptors() {
|
||||
INTERCEPT_FUNCTION(stpcpy); // NOLINT
|
||||
INTERCEPT_FUNCTION(strdup);
|
||||
MSAN_MAYBE_INTERCEPT___STRDUP;
|
||||
INTERCEPT_FUNCTION(strndup);
|
||||
MSAN_MAYBE_INTERCEPT___STRNDUP;
|
||||
INTERCEPT_FUNCTION(strncpy); // NOLINT
|
||||
INTERCEPT_FUNCTION(gcvt);
|
||||
INTERCEPT_FUNCTION(strcat); // NOLINT
|
||||
|
@ -34,6 +34,8 @@
|
||||
// COMMON_INTERCEPTOR_MEMSET_IMPL
|
||||
// COMMON_INTERCEPTOR_MEMMOVE_IMPL
|
||||
// COMMON_INTERCEPTOR_MEMCPY_IMPL
|
||||
// COMMON_INTERCEPTOR_COPY_STRING
|
||||
// COMMON_INTERCEPTOR_STRNDUP_IMPL
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "interception/interception.h"
|
||||
@ -217,6 +219,24 @@ bool PlatformHasDifferentMemcpyAndMemmove();
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef COMMON_INTERCEPTOR_COPY_STRING
|
||||
#define COMMON_INTERCEPTOR_COPY_STRING(ctx, to, from, size) {}
|
||||
#endif
|
||||
|
||||
#ifndef COMMON_INTERCEPTOR_STRNDUP_IMPL
|
||||
#define COMMON_INTERCEPTOR_STRNDUP_IMPL(ctx, s, size) \
|
||||
COMMON_INTERCEPTOR_ENTER(ctx, strndup, s, size); \
|
||||
uptr copy_length = internal_strnlen(s, size); \
|
||||
char *new_mem = (char *)WRAP(malloc)(copy_length + 1); \
|
||||
if (common_flags()->intercept_strndup) { \
|
||||
COMMON_INTERCEPTOR_READ_STRING(ctx, s, Min(size, copy_length + 1)); \
|
||||
} \
|
||||
COMMON_INTERCEPTOR_COPY_STRING(ctx, new_mem, s, copy_length); \
|
||||
internal_memcpy(new_mem, s, copy_length); \
|
||||
new_mem[copy_length] = '\0'; \
|
||||
return new_mem;
|
||||
#endif
|
||||
|
||||
struct FileMetadata {
|
||||
// For open_memstream().
|
||||
char **addr;
|
||||
@ -300,6 +320,26 @@ INTERCEPTOR(SIZE_T, strnlen, const char *s, SIZE_T maxlen) {
|
||||
#define INIT_STRNLEN
|
||||
#endif
|
||||
|
||||
#if SANITIZER_INTERCEPT_STRNDUP
|
||||
INTERCEPTOR(char*, strndup, const char *s, uptr size) {
|
||||
void *ctx;
|
||||
COMMON_INTERCEPTOR_STRNDUP_IMPL(ctx, s, size);
|
||||
}
|
||||
#define INIT_STRNDUP COMMON_INTERCEPT_FUNCTION(strndup)
|
||||
#else
|
||||
#define INIT_STRNDUP
|
||||
#endif // SANITIZER_INTERCEPT_STRNDUP
|
||||
|
||||
#if SANITIZER_INTERCEPT___STRNDUP
|
||||
INTERCEPTOR(char*, __strndup, const char *s, uptr size) {
|
||||
void *ctx;
|
||||
COMMON_INTERCEPTOR_STRNDUP_IMPL(ctx, s, size);
|
||||
}
|
||||
#define INIT___STRNDUP COMMON_INTERCEPT_FUNCTION(__strndup)
|
||||
#else
|
||||
#define INIT___STRNDUP
|
||||
#endif // SANITIZER_INTERCEPT___STRNDUP
|
||||
|
||||
#if SANITIZER_INTERCEPT_TEXTDOMAIN
|
||||
INTERCEPTOR(char*, textdomain, const char *domainname) {
|
||||
void *ctx;
|
||||
@ -6163,6 +6203,8 @@ static void InitializeCommonInterceptors() {
|
||||
INIT_TEXTDOMAIN;
|
||||
INIT_STRLEN;
|
||||
INIT_STRNLEN;
|
||||
INIT_STRNDUP;
|
||||
INIT___STRNDUP;
|
||||
INIT_STRCMP;
|
||||
INIT_STRNCMP;
|
||||
INIT_STRCASECMP;
|
||||
|
@ -8,14 +8,9 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Sanitizer Coverage interface list.
|
||||
//===----------------------------------------------------------------------===//
|
||||
INTERFACE_FUNCTION(__sanitizer_cov)
|
||||
INTERFACE_FUNCTION(__sanitizer_cov_dump)
|
||||
INTERFACE_FUNCTION(__sanitizer_cov_init)
|
||||
INTERFACE_FUNCTION(__sanitizer_cov_module_init)
|
||||
INTERFACE_FUNCTION(__sanitizer_cov_with_check)
|
||||
INTERFACE_FUNCTION(__sanitizer_dump_coverage)
|
||||
INTERFACE_FUNCTION(__sanitizer_dump_trace_pc_guard_coverage)
|
||||
INTERFACE_FUNCTION(__sanitizer_get_total_unique_coverage)
|
||||
INTERFACE_FUNCTION(__sanitizer_maybe_open_cov_file)
|
||||
INTERFACE_WEAK_FUNCTION(__sancov_default_options)
|
||||
INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_cmp)
|
||||
|
@ -155,13 +155,6 @@ void CoverageData::DirectOpen() {
|
||||
|
||||
void CoverageData::Init() {
|
||||
pc_fd = kInvalidFd;
|
||||
|
||||
if (!common_flags()->coverage) return;
|
||||
Printf("**\n***\n***\n");
|
||||
Printf("**WARNING: this implementation of SanitizerCoverage is deprecated\n");
|
||||
Printf("**WARNING: and will be removed in future versions\n");
|
||||
Printf("**WARNING: See https://clang.llvm.org/docs/SanitizerCoverage.html\n");
|
||||
Printf("**\n***\n***\n");
|
||||
}
|
||||
|
||||
void CoverageData::Enable() {
|
||||
@ -495,6 +488,12 @@ static void GenerateHtmlReport(const InternalMmapVector<char *> &cov_files) {
|
||||
void CoverageData::DumpOffsets() {
|
||||
auto sym = Symbolizer::GetOrInit();
|
||||
if (!common_flags()->coverage_pcs) return;
|
||||
Printf("**\n***\n***\n");
|
||||
Printf("**WARNING: this implementation of SanitizerCoverage is deprecated\n");
|
||||
Printf("**WARNING: and will be removed in future versions\n");
|
||||
Printf("**WARNING: See https://clang.llvm.org/docs/SanitizerCoverage.html\n");
|
||||
Printf("**\n***\n***\n");
|
||||
|
||||
CHECK_NE(sym, nullptr);
|
||||
InternalMmapVector<uptr> offsets(0);
|
||||
InternalScopedString path(kMaxPathLength);
|
||||
@ -607,47 +606,13 @@ void CoverageUpdateMapping() {
|
||||
} // namespace __sanitizer
|
||||
|
||||
extern "C" {
|
||||
SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov(u32 *guard) {
|
||||
coverage_data.Add(StackTrace::GetPreviousInstructionPc(GET_CALLER_PC()),
|
||||
guard);
|
||||
}
|
||||
SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_with_check(u32 *guard) {
|
||||
atomic_uint32_t *atomic_guard = reinterpret_cast<atomic_uint32_t*>(guard);
|
||||
if (static_cast<s32>(
|
||||
__sanitizer::atomic_load(atomic_guard, memory_order_relaxed)) < 0)
|
||||
coverage_data.Add(StackTrace::GetPreviousInstructionPc(GET_CALLER_PC()),
|
||||
guard);
|
||||
}
|
||||
SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_init() {
|
||||
coverage_enabled = true;
|
||||
coverage_dir = common_flags()->coverage_dir;
|
||||
coverage_data.Init();
|
||||
}
|
||||
SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_dump() {
|
||||
coverage_data.DumpAll();
|
||||
__sanitizer_dump_trace_pc_guard_coverage();
|
||||
}
|
||||
SANITIZER_INTERFACE_ATTRIBUTE void
|
||||
__sanitizer_cov_module_init(s32 *guards, uptr npcs, u8 *counters,
|
||||
const char *comp_unit_name) {
|
||||
coverage_data.InitializeGuards(guards, npcs, comp_unit_name, GET_CALLER_PC());
|
||||
if (!common_flags()->coverage_direct) return;
|
||||
if (SANITIZER_ANDROID && coverage_enabled) {
|
||||
// dlopen/dlclose interceptors do not work on Android, so we rely on
|
||||
// Extend() calls to update .sancov.map.
|
||||
CovUpdateMapping(coverage_dir, GET_CALLER_PC());
|
||||
}
|
||||
coverage_data.Extend(npcs);
|
||||
}
|
||||
SANITIZER_INTERFACE_ATTRIBUTE
|
||||
sptr __sanitizer_maybe_open_cov_file(const char *name) {
|
||||
return (sptr)MaybeOpenCovFile(name);
|
||||
}
|
||||
SANITIZER_INTERFACE_ATTRIBUTE
|
||||
uptr __sanitizer_get_total_unique_coverage() {
|
||||
return atomic_load(&coverage_counter, memory_order_relaxed);
|
||||
}
|
||||
|
||||
// Default empty implementations (weak). Users should redefine them.
|
||||
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp, void) {}
|
||||
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp1, void) {}
|
||||
|
@ -49,7 +49,7 @@ static void WriteModuleCoverage(char* file_path, const char* module_name,
|
||||
WriteToFile(fd, &Magic, sizeof(Magic));
|
||||
WriteToFile(fd, pcs, len * sizeof(*pcs));
|
||||
CloseFile(fd);
|
||||
Printf("SanitizerCoverage: %s %zd PCs written\n", file_path, len);
|
||||
Printf("SanitizerCoverage: %s: %zd PCs written\n", file_path, len);
|
||||
}
|
||||
|
||||
static void SanitizerDumpCoverage(const uptr* unsorted_pcs, uptr len) {
|
||||
@ -71,7 +71,7 @@ static void SanitizerDumpCoverage(const uptr* unsorted_pcs, uptr len) {
|
||||
if (!pc) continue;
|
||||
|
||||
if (!__sanitizer_get_module_and_offset_for_pc(pc, nullptr, 0, &pcs[i])) {
|
||||
Printf("ERROR: bad pc %x\n", pc);
|
||||
Printf("ERROR: unknown pc 0x%x (may happen if dlclose is used)\n", pc);
|
||||
continue;
|
||||
}
|
||||
uptr module_base = pc - pcs[i];
|
||||
|
@ -197,6 +197,9 @@ COMMON_FLAG(bool, intercept_strpbrk, true,
|
||||
COMMON_FLAG(bool, intercept_strlen, true,
|
||||
"If set, uses custom wrappers for strlen and strnlen functions "
|
||||
"to find more errors.")
|
||||
COMMON_FLAG(bool, intercept_strndup, true,
|
||||
"If set, uses custom wrappers for strndup functions "
|
||||
"to find more errors.")
|
||||
COMMON_FLAG(bool, intercept_strchr, true,
|
||||
"If set, uses custom wrappers for strchr, strchrnul, and strrchr "
|
||||
"functions to find more errors.")
|
||||
|
@ -25,6 +25,12 @@
|
||||
# define SI_NOT_WINDOWS 0
|
||||
#endif
|
||||
|
||||
#if SANITIZER_POSIX
|
||||
# define SI_POSIX 1
|
||||
#else
|
||||
# define SI_POSIX 0
|
||||
#endif
|
||||
|
||||
#if SANITIZER_LINUX && !SANITIZER_ANDROID
|
||||
# define SI_LINUX_NOT_ANDROID 1
|
||||
#else
|
||||
@ -69,6 +75,12 @@
|
||||
# define SI_UNIX_NOT_MAC 0
|
||||
#endif
|
||||
|
||||
#if SANITIZER_LINUX && !SANITIZER_FREEBSD
|
||||
# define SI_LINUX_NOT_FREEBSD 1
|
||||
# else
|
||||
# define SI_LINUX_NOT_FREEBSD 0
|
||||
#endif
|
||||
|
||||
#define SANITIZER_INTERCEPT_STRLEN 1
|
||||
#define SANITIZER_INTERCEPT_STRNLEN SI_NOT_MAC
|
||||
#define SANITIZER_INTERCEPT_STRCMP 1
|
||||
@ -86,6 +98,8 @@
|
||||
#define SANITIZER_INTERCEPT_MEMMOVE 1
|
||||
#define SANITIZER_INTERCEPT_MEMCPY 1
|
||||
#define SANITIZER_INTERCEPT_MEMCMP 1
|
||||
#define SANITIZER_INTERCEPT_STRNDUP SI_POSIX
|
||||
#define SANITIZER_INTERCEPT___STRNDUP SI_LINUX_NOT_FREEBSD
|
||||
#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && \
|
||||
__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 1070
|
||||
# define SI_MAC_DEPLOYMENT_BELOW_10_7 1
|
||||
|
@ -59,6 +59,7 @@ getpagesize U
|
||||
getpid U
|
||||
gettimeofday U
|
||||
ioctl U
|
||||
isalpha U
|
||||
isatty U
|
||||
isprint U
|
||||
isupper U
|
||||
|
@ -197,7 +197,7 @@ struct VtablePrefix {
|
||||
};
|
||||
VtablePrefix *getVtablePrefix(void *Vtable) {
|
||||
VtablePrefix *Vptr = reinterpret_cast<VtablePrefix*>(Vtable);
|
||||
if (!Vptr)
|
||||
if (!IsAccessibleMemoryRange((uptr)Vptr, sizeof(VtablePrefix)))
|
||||
return nullptr;
|
||||
VtablePrefix *Prefix = Vptr - 1;
|
||||
if (!Prefix->TypeInfo)
|
||||
|
@ -14,12 +14,14 @@
|
||||
#include <__config>
|
||||
#include <algorithm>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _Cp, bool _IsConst, typename _Cp::__storage_type = 0> class __bit_iterator;
|
||||
@ -1273,4 +1275,6 @@ private:
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP___BIT_REFERENCE
|
||||
|
@ -220,10 +220,12 @@
|
||||
#endif // __NetBSD__
|
||||
|
||||
#if defined(_WIN32)
|
||||
# define _LIBCPP_WIN32API 1
|
||||
# define _LIBCPP_WIN32API
|
||||
# define _LIBCPP_LITTLE_ENDIAN 1
|
||||
# define _LIBCPP_BIG_ENDIAN 0
|
||||
# define _LIBCPP_SHORT_WCHAR 1
|
||||
// Both MinGW and native MSVC provide a "MSVC"-like enviroment
|
||||
# define _LIBCPP_MSVCRT_LIKE
|
||||
// If mingw not explicitly detected, assume using MS C runtime only.
|
||||
# ifndef __MINGW32__
|
||||
# define _LIBCPP_MSVCRT // Using Microsoft's C Runtime library
|
||||
@ -1205,4 +1207,34 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
|
||||
#define _LIBCPP_AVAILABILITY_NO_STREAMS_EXTERN_TEMPLATE
|
||||
#endif
|
||||
|
||||
#if defined(_LIBCPP_COMPILER_IBM)
|
||||
#define _LIBCPP_HAS_NO_PRAGMA_PUSH_POP_MACRO
|
||||
#endif
|
||||
|
||||
#if defined(_LIBCPP_HAS_NO_PRAGMA_PUSH_POP_MACRO)
|
||||
# define _LIBCPP_PUSH_MACROS
|
||||
# define _LIBCPP_POP_MACROS
|
||||
#else
|
||||
// Don't warn about macro conflicts when we can restore them at the
|
||||
// end of the header.
|
||||
# ifndef _LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS
|
||||
# define _LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS
|
||||
# endif
|
||||
# if defined(_LIBCPP_COMPILER_MSVC)
|
||||
# define _LIBCPP_PUSH_MACROS \
|
||||
__pragma(push_macro("min")) \
|
||||
__pragma(push_macro("max"))
|
||||
# define _LIBCPP_POP_MACROS \
|
||||
__pragma(pop_macro("min")) \
|
||||
__pragma(pop_macro("max"))
|
||||
# else
|
||||
# define _LIBCPP_PUSH_MACROS \
|
||||
_Pragma("push_macro(\"min\")") \
|
||||
_Pragma("push_macro(\"max\")")
|
||||
# define _LIBCPP_POP_MACROS \
|
||||
_Pragma("pop_macro(\"min\")") \
|
||||
_Pragma("pop_macro(\"max\")")
|
||||
# endif
|
||||
#endif // defined(_LIBCPP_HAS_NO_PRAGMA_PUSH_POP_MACRO)
|
||||
|
||||
#endif // _LIBCPP_CONFIG
|
||||
|
@ -20,17 +20,18 @@
|
||||
#include <utility>
|
||||
#include <type_traits>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#include <__debug>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
template <class _Key, class _Tp>
|
||||
union __hash_value_type;
|
||||
@ -2667,6 +2668,9 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__subscriptable(const const_iterator*,
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_DEBUG_LEVEL >= 2
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP__HASH_TABLE
|
||||
|
@ -19,7 +19,7 @@
|
||||
#include <cstdint>
|
||||
#include <cctype>
|
||||
#include <locale.h>
|
||||
#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
|
||||
#if defined(_LIBCPP_MSVCRT_LIKE)
|
||||
# include <support/win32/locale_win32.h>
|
||||
#elif defined(_AIX)
|
||||
# include <support/ibm/xlocale.h>
|
||||
@ -367,7 +367,7 @@ public:
|
||||
static const mask punct = _ISpunct;
|
||||
static const mask xdigit = _ISxdigit;
|
||||
static const mask blank = _ISblank;
|
||||
#elif defined(_LIBCPP_MSVCRT)
|
||||
#elif defined(_LIBCPP_MSVCRT_LIKE)
|
||||
typedef unsigned short mask;
|
||||
static const mask space = _SPACE;
|
||||
static const mask print = _BLANK|_PUNCT|_ALPHA|_DIGIT;
|
||||
|
@ -15,12 +15,16 @@
|
||||
#include <chrono>
|
||||
#include <system_error>
|
||||
#include <__threading_support>
|
||||
#include <__undef_min_max>
|
||||
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_THREADS
|
||||
@ -428,4 +432,6 @@ condition_variable::wait_for(unique_lock<mutex>& __lk,
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP___MUTEX_BASE
|
||||
|
@ -6,12 +6,14 @@
|
||||
#include <type_traits>
|
||||
#include <algorithm>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <bool>
|
||||
@ -628,7 +630,8 @@ swap(__split_buffer<_Tp, _Allocator>& __x, __split_buffer<_Tp, _Allocator>& __y)
|
||||
__x.swap(__y);
|
||||
}
|
||||
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_SPLIT_BUFFER
|
||||
|
@ -17,12 +17,14 @@
|
||||
#include <__locale>
|
||||
#include <cstdio>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
static const int __limit = 8;
|
||||
@ -355,4 +357,6 @@ __stdoutbuf<_CharT>::imbue(const locale& __loc)
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP___STD_STREAM
|
||||
|
@ -57,14 +57,16 @@ template <> struct char_traits<wchar_t>;
|
||||
#include <cstdio> // For EOF.
|
||||
#include <memory> // for __murmur2_or_cityhash
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#include <__debug>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
// char_traits
|
||||
@ -870,4 +872,6 @@ struct __quoted_output_proxy
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP___STRING
|
||||
|
@ -30,9 +30,12 @@
|
||||
#include <windows.h>
|
||||
#include <process.h>
|
||||
#include <fibersapi.h>
|
||||
#include <__undef_min_max>
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
#if defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) || \
|
||||
defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL)
|
||||
#define _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_FUNC_VIS
|
||||
@ -629,6 +632,8 @@ int __libcpp_tls_set(__libcpp_tls_key __key, void *__p)
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // !_LIBCPP_HAS_NO_THREADS
|
||||
|
||||
#endif // _LIBCPP_THREADING_SUPPORT
|
||||
|
@ -17,12 +17,14 @@
|
||||
#include <stdexcept>
|
||||
#include <algorithm>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _Tp, class _Compare, class _Allocator> class __tree;
|
||||
@ -2685,4 +2687,6 @@ swap(__tree<_Tp, _Compare, _Allocator>& __x,
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP___TREE
|
||||
|
@ -1,13 +1,14 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//===------------------------ __undef_macros ------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
|
||||
#ifdef min
|
||||
#if !defined(_LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS)
|
||||
#if defined(_LIBCPP_WARNING)
|
@ -651,14 +651,16 @@ template <class BidirectionalIterator, class Compare>
|
||||
#include <intrin.h>
|
||||
#endif
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#include <__debug>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
// I'd like to replace these with _VSTD::equal_to<void>, but can't because:
|
||||
@ -2908,11 +2910,11 @@ struct __log2_imp<0, _Rp>
|
||||
static const size_t value = _Rp + 1;
|
||||
};
|
||||
|
||||
template <class _UI, _UI _Xp>
|
||||
template <class _UIntType, _UIntType _Xp>
|
||||
struct __log2
|
||||
{
|
||||
static const size_t value = __log2_imp<_Xp,
|
||||
sizeof(_UI) * __CHAR_BIT__ - 1>::value;
|
||||
sizeof(_UIntType) * __CHAR_BIT__ - 1>::value;
|
||||
};
|
||||
|
||||
template<class _Engine, class _UIntType>
|
||||
@ -5904,4 +5906,6 @@ prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_ALGORITHM
|
||||
|
@ -113,6 +113,8 @@ template <size_t I, class T, size_t N> const T&& get(const array<T, N>&&) noexce
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _Tp, size_t _Size>
|
||||
|
@ -113,10 +113,6 @@ template <size_t N> struct hash<std::bitset<N>>;
|
||||
|
||||
*/
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#include <__config>
|
||||
#include <__bit_reference>
|
||||
#include <cstddef>
|
||||
@ -126,7 +122,13 @@ template <size_t N> struct hash<std::bitset<N>>;
|
||||
#include <iosfwd>
|
||||
#include <__functional_base>
|
||||
|
||||
#include <__undef_min_max>
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@ -1090,4 +1092,6 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x);
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_BITSET
|
||||
|
@ -305,12 +305,14 @@ constexpr chrono::duration<unspecified , nano> operator "" ns(long doub
|
||||
#include <ratio>
|
||||
#include <limits>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
namespace chrono
|
||||
@ -1160,4 +1162,6 @@ namespace chrono { // hoist the literals into namespace std::chrono
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_CHRONO
|
||||
|
@ -150,10 +150,6 @@ template <class T, class Allocator>
|
||||
|
||||
*/
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#include <__config>
|
||||
#include <__split_buffer>
|
||||
#include <type_traits>
|
||||
@ -162,7 +158,13 @@ template <class T, class Allocator>
|
||||
#include <algorithm>
|
||||
#include <stdexcept>
|
||||
|
||||
#include <__undef_min_max>
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@ -2900,4 +2902,6 @@ swap(deque<_Tp, _Allocator>& __x, deque<_Tp, _Allocator>& __y)
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_DEQUE
|
||||
|
@ -39,17 +39,18 @@ SampleIterator sample(PopulationIterator first, PopulationIterator last,
|
||||
#include <algorithm>
|
||||
#include <type_traits>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#include <__debug>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_LFTS
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_LFTS
|
||||
|
||||
template <class _ForwardIterator, class _Searcher>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_ForwardIterator search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher &__s)
|
||||
@ -67,4 +68,6 @@ _SampleIterator sample(_PopulationIterator __first, _PopulationIterator __last,
|
||||
|
||||
_LIBCPP_END_NAMESPACE_LFTS
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif /* _LIBCPP_EXPERIMENTAL_ALGORITHM */
|
||||
|
@ -107,6 +107,9 @@ public:
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
namespace std { namespace experimental { inline namespace __array_extensions_v1 {
|
||||
|
||||
template <class _Tp>
|
||||
@ -295,5 +298,7 @@ template <class _Tp, class _Alloc>
|
||||
struct _LIBCPP_TEMPLATE_VIS uses_allocator<std::experimental::dynarray<_Tp>, _Alloc> : true_type {};
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // if _LIBCPP_STD_VER > 11
|
||||
#endif // _LIBCPP_DYNARRAY
|
||||
|
@ -89,21 +89,22 @@ inline namespace fundamentals_v1 {
|
||||
|
||||
#include <experimental/__config>
|
||||
#include <functional>
|
||||
|
||||
#include <algorithm>
|
||||
#include <type_traits>
|
||||
#include <vector>
|
||||
#include <array>
|
||||
#include <unordered_map>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#include <__debug>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_LFTS
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
@ -456,4 +457,6 @@ make_boyer_moore_horspool_searcher( _RandomAccessIterator __f, _RandomAccessIter
|
||||
|
||||
_LIBCPP_END_NAMESPACE_LFTS
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif /* _LIBCPP_EXPERIMENTAL_FUNCTIONAL */
|
||||
|
@ -82,6 +82,9 @@ namespace pmr {
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
|
||||
|
||||
// Round __s up to next multiple of __a.
|
||||
@ -419,4 +422,6 @@ using resource_adaptor = __resource_adaptor_imp<
|
||||
|
||||
_LIBCPP_END_NAMESPACE_LFTS_PMR
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif /* _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE */
|
||||
|
@ -41,6 +41,9 @@ inline namespace fundamentals_v2 {
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_LFTS_V2
|
||||
@ -110,4 +113,7 @@ lcm(_Tp __m, _Up __n)
|
||||
_LIBCPP_END_NAMESPACE_LFTS_V2
|
||||
|
||||
#endif /* _LIBCPP_STD_VER > 11 */
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif /* _LIBCPP_EXPERIMENTAL_NUMERIC */
|
||||
|
@ -143,6 +143,21 @@ namespace std { namespace experimental { inline namespace fundamentals_v1 {
|
||||
#include <experimental/__config>
|
||||
#include <functional>
|
||||
#include <stdexcept>
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
#include <initializer_list>
|
||||
#include <type_traits>
|
||||
#include <new>
|
||||
#include <__functional_base>
|
||||
#include <__debug>
|
||||
#endif
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
|
||||
class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access
|
||||
@ -160,17 +175,6 @@ _LIBCPP_END_NAMESPACE_EXPERIMENTAL
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
|
||||
#include <initializer_list>
|
||||
#include <type_traits>
|
||||
#include <new>
|
||||
#include <__functional_base>
|
||||
#include <__undef_min_max>
|
||||
#include <__debug>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_LFTS
|
||||
|
||||
struct in_place_t {};
|
||||
@ -913,4 +917,6 @@ _LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
#endif // _LIBCPP_STD_VER > 11
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_EXPERIMENTAL_OPTIONAL
|
||||
|
@ -189,6 +189,9 @@ namespace std {
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_LFTS
|
||||
|
||||
template<class _CharT, class _Traits = _VSTD::char_traits<_CharT> >
|
||||
@ -810,4 +813,6 @@ quoted ( std::experimental::basic_string_view <_CharT, _Traits> __sv,
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_LFTS_STRING_VIEW
|
||||
|
@ -167,19 +167,20 @@ template <class T, class Allocator>
|
||||
*/
|
||||
|
||||
#include <__config>
|
||||
|
||||
#include <initializer_list>
|
||||
#include <memory>
|
||||
#include <limits>
|
||||
#include <iterator>
|
||||
#include <algorithm>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _Tp, class _VoidPtr> struct __forward_list_node;
|
||||
@ -1719,4 +1720,6 @@ swap(forward_list<_Tp, _Alloc>& __x, forward_list<_Tp, _Alloc>& __y)
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_FORWARD_LIST
|
||||
|
@ -171,12 +171,14 @@ typedef basic_fstream<wchar_t> wfstream;
|
||||
#include <__locale>
|
||||
#include <cstdio>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _CharT, class _Traits>
|
||||
@ -1476,4 +1478,6 @@ basic_fstream<_CharT, _Traits>::close()
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_FSTREAM
|
||||
|
@ -162,12 +162,14 @@ template <class charT, class traits, class T>
|
||||
#include <__config>
|
||||
#include <ostream>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _CharT, class _Traits>
|
||||
@ -1683,4 +1685,6 @@ _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_iostream<ch
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_ISTREAM
|
||||
|
@ -102,15 +102,8 @@ template<> class numeric_limits<cv long double>;
|
||||
|
||||
*/
|
||||
#include <__config>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if defined(_LIBCPP_COMPILER_MSVC)
|
||||
#include "support/win32/limits_msvc_win32.h"
|
||||
#endif // _LIBCPP_MSVCRT
|
||||
@ -119,6 +112,14 @@ template<> class numeric_limits<cv long double>;
|
||||
#include "support/ibm/limits.h"
|
||||
#endif // __IBMCPP__
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
enum float_round_style
|
||||
@ -182,14 +183,14 @@ protected:
|
||||
static _LIBCPP_CONSTEXPR const float_round_style round_style = round_toward_zero;
|
||||
};
|
||||
|
||||
template <class _Tp, int digits, bool _IsSigned>
|
||||
template <class _Tp, int __digits, bool _IsSigned>
|
||||
struct __libcpp_compute_min
|
||||
{
|
||||
static _LIBCPP_CONSTEXPR const _Tp value = _Tp(_Tp(1) << digits);
|
||||
static _LIBCPP_CONSTEXPR const _Tp value = _Tp(_Tp(1) << __digits);
|
||||
};
|
||||
|
||||
template <class _Tp, int digits>
|
||||
struct __libcpp_compute_min<_Tp, digits, false>
|
||||
template <class _Tp, int __digits>
|
||||
struct __libcpp_compute_min<_Tp, __digits, false>
|
||||
{
|
||||
static _LIBCPP_CONSTEXPR const _Tp value = _Tp(0);
|
||||
};
|
||||
@ -811,4 +812,6 @@ template <class _Tp>
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_LIMITS
|
||||
|
@ -177,14 +177,16 @@ template <class T, class Alloc>
|
||||
#include <algorithm>
|
||||
#include <type_traits>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#include <__debug>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _Tp, class _VoidPtr> struct __list_node;
|
||||
@ -2415,4 +2417,6 @@ swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_LIST
|
||||
|
@ -192,14 +192,7 @@ template <class charT> class messages_byname;
|
||||
#endif
|
||||
#include <cstdlib>
|
||||
#include <ctime>
|
||||
#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
|
||||
#include <support/win32/locale_win32.h>
|
||||
#elif defined(_NEWLIB_VERSION)
|
||||
// FIXME: replace all the uses of _NEWLIB_VERSION with __NEWLIB__ preceded by an
|
||||
// include of <sys/cdefs.h> once https://sourceware.org/ml/newlib-cvs/2014-q3/msg00038.html
|
||||
// has had a chance to bake for a bit
|
||||
#include <support/newlib/xlocale.h>
|
||||
#endif
|
||||
#include <cstdio>
|
||||
#ifdef _LIBCPP_HAS_CATOPEN
|
||||
#include <nl_types.h>
|
||||
#endif
|
||||
@ -208,18 +201,20 @@ template <class charT> class messages_byname;
|
||||
#include <Availability.h>
|
||||
#endif
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
|
||||
#include <__bsd_locale_defaults.h>
|
||||
#else
|
||||
#include <__bsd_locale_fallbacks.h>
|
||||
#endif
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
#if defined(__APPLE__) || defined(__FreeBSD__)
|
||||
@ -4274,4 +4269,6 @@ wbuffer_convert<_Codecvt, _Elem, _Tr>::__close()
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_LOCALE
|
||||
|
@ -658,12 +658,14 @@ void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
|
||||
# include <atomic>
|
||||
#endif
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _ValueType>
|
||||
@ -1541,7 +1543,7 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits
|
||||
{return __a.allocate(__n);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
|
||||
{return allocate(__a, __n, __hint,
|
||||
{return __allocate(__a, __n, __hint,
|
||||
__has_allocate_hint<allocator_type, size_type, const_void_pointer>());}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@ -1595,7 +1597,7 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static allocator_type
|
||||
select_on_container_copy_construction(const allocator_type& __a)
|
||||
{return select_on_container_copy_construction(
|
||||
{return __select_on_container_copy_construction(
|
||||
__has_select_on_container_copy_construction<const allocator_type>(),
|
||||
__a);}
|
||||
|
||||
@ -1694,11 +1696,11 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits
|
||||
private:
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static pointer allocate(allocator_type& __a, size_type __n,
|
||||
static pointer __allocate(allocator_type& __a, size_type __n,
|
||||
const_void_pointer __hint, true_type)
|
||||
{return __a.allocate(__n, __hint);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static pointer allocate(allocator_type& __a, size_type __n,
|
||||
static pointer __allocate(allocator_type& __a, size_type __n,
|
||||
const_void_pointer, false_type)
|
||||
{return __a.allocate(__n);}
|
||||
|
||||
@ -1735,11 +1737,11 @@ private:
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static allocator_type
|
||||
select_on_container_copy_construction(true_type, const allocator_type& __a)
|
||||
__select_on_container_copy_construction(true_type, const allocator_type& __a)
|
||||
{return __a.select_on_container_copy_construction();}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static allocator_type
|
||||
select_on_container_copy_construction(false_type, const allocator_type& __a)
|
||||
__select_on_container_copy_construction(false_type, const allocator_type& __a)
|
||||
{return __a;}
|
||||
};
|
||||
|
||||
@ -3101,28 +3103,28 @@ struct _LIBCPP_TEMPLATE_VIS hash<__enable_hash_helper<
|
||||
struct __destruct_n
|
||||
{
|
||||
private:
|
||||
size_t size;
|
||||
size_t __size_;
|
||||
|
||||
template <class _Tp>
|
||||
_LIBCPP_INLINE_VISIBILITY void __process(_Tp* __p, false_type) _NOEXCEPT
|
||||
{for (size_t __i = 0; __i < size; ++__i, ++__p) __p->~_Tp();}
|
||||
{for (size_t __i = 0; __i < __size_; ++__i, ++__p) __p->~_Tp();}
|
||||
|
||||
template <class _Tp>
|
||||
_LIBCPP_INLINE_VISIBILITY void __process(_Tp*, true_type) _NOEXCEPT
|
||||
{}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY void __incr(false_type) _NOEXCEPT
|
||||
{++size;}
|
||||
{++__size_;}
|
||||
_LIBCPP_INLINE_VISIBILITY void __incr(true_type) _NOEXCEPT
|
||||
{}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY void __set(size_t __s, false_type) _NOEXCEPT
|
||||
{size = __s;}
|
||||
{__size_ = __s;}
|
||||
_LIBCPP_INLINE_VISIBILITY void __set(size_t, true_type) _NOEXCEPT
|
||||
{}
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY explicit __destruct_n(size_t __s) _NOEXCEPT
|
||||
: size(__s) {}
|
||||
: __size_(__s) {}
|
||||
|
||||
template <class _Tp>
|
||||
_LIBCPP_INLINE_VISIBILITY void __incr(_Tp*) _NOEXCEPT
|
||||
@ -5574,4 +5576,6 @@ struct __temp_value {
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_MEMORY
|
||||
|
@ -484,7 +484,7 @@ module std [system] {
|
||||
module __string { header "__string" export * }
|
||||
module __tree { header "__tree" export * }
|
||||
module __tuple { header "__tuple" export * }
|
||||
module __undef_min_max { header "__undef_min_max" export * }
|
||||
module __undef_macros { header "__undef_macros" export * }
|
||||
|
||||
module experimental {
|
||||
requires cplusplus11
|
||||
|
@ -196,12 +196,14 @@ template<class Callable, class ...Args>
|
||||
#endif
|
||||
#include <__threading_support>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_THREADS
|
||||
@ -696,4 +698,6 @@ call_once(once_flag& __flag, const _Callable& __func)
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_MUTEX
|
||||
|
@ -71,6 +71,9 @@ template <class M, class N>
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _InputIterator, class _Tp>
|
||||
@ -267,4 +270,6 @@ lcm(_Tp __m, _Up __n)
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_NUMERIC
|
||||
|
@ -146,7 +146,6 @@ namespace std {
|
||||
#include <__config>
|
||||
#include <__debug>
|
||||
#include <__functional_base>
|
||||
#include <__undef_min_max>
|
||||
#include <functional>
|
||||
#include <initializer_list>
|
||||
#include <new>
|
||||
@ -158,6 +157,10 @@ namespace std {
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
namespace std // purposefully not using versioning namespace
|
||||
{
|
||||
|
||||
@ -1315,4 +1318,6 @@ _LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
#endif // _LIBCPP_STD_VER > 14
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_OPTIONAL
|
||||
|
@ -1646,12 +1646,14 @@ class piecewise_linear_distribution
|
||||
#include <istream>
|
||||
#include <ostream>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
// __is_seed_sequence
|
||||
@ -2013,41 +2015,41 @@ template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
|
||||
_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
|
||||
class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine;
|
||||
|
||||
template <class _UI, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UI _Ap, size_t _Up, _UI _Dp, size_t _Sp,
|
||||
_UI _Bp, size_t _Tp, _UI _Cp, size_t _Lp, _UI _Fp>
|
||||
template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
|
||||
_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
|
||||
bool
|
||||
operator==(const mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __x,
|
||||
const mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __y);
|
||||
|
||||
template <class _UI, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UI _Ap, size_t _Up, _UI _Dp, size_t _Sp,
|
||||
_UI _Bp, size_t _Tp, _UI _Cp, size_t _Lp, _UI _Fp>
|
||||
template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
|
||||
_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator!=(const mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __x,
|
||||
const mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __y);
|
||||
|
||||
template <class _CharT, class _Traits,
|
||||
class _UI, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UI _Ap, size_t _Up, _UI _Dp, size_t _Sp,
|
||||
_UI _Bp, size_t _Tp, _UI _Cp, size_t _Lp, _UI _Fp>
|
||||
class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
|
||||
_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __os,
|
||||
const mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __x);
|
||||
|
||||
template <class _CharT, class _Traits,
|
||||
class _UI, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UI _Ap, size_t _Up, _UI _Dp, size_t _Sp,
|
||||
_UI _Bp, size_t _Tp, _UI _Cp, size_t _Lp, _UI _Fp>
|
||||
class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
|
||||
_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
|
||||
basic_istream<_CharT, _Traits>&
|
||||
operator>>(basic_istream<_CharT, _Traits>& __is,
|
||||
mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __x);
|
||||
|
||||
template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
|
||||
@ -2129,44 +2131,44 @@ public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
|
||||
|
||||
template <class _UI, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UI _Ap, size_t _Up, _UI _Dp, size_t _Sp,
|
||||
_UI _Bp, size_t _Tp, _UI _Cp, size_t _Lp, _UI _Fp>
|
||||
template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
|
||||
_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
|
||||
friend
|
||||
bool
|
||||
operator==(const mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __x,
|
||||
const mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __y);
|
||||
|
||||
template <class _UI, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UI _Ap, size_t _Up, _UI _Dp, size_t _Sp,
|
||||
_UI _Bp, size_t _Tp, _UI _Cp, size_t _Lp, _UI _Fp>
|
||||
template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
|
||||
_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
|
||||
friend
|
||||
bool
|
||||
operator!=(const mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __x,
|
||||
const mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __y);
|
||||
|
||||
template <class _CharT, class _Traits,
|
||||
class _UI, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UI _Ap, size_t _Up, _UI _Dp, size_t _Sp,
|
||||
_UI _Bp, size_t _Tp, _UI _Cp, size_t _Lp, _UI _Fp>
|
||||
class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
|
||||
_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
|
||||
friend
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __os,
|
||||
const mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __x);
|
||||
|
||||
template <class _CharT, class _Traits,
|
||||
class _UI, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UI _Ap, size_t _Up, _UI _Dp, size_t _Sp,
|
||||
_UI _Bp, size_t _Tp, _UI _Cp, size_t _Lp, _UI _Fp>
|
||||
class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
|
||||
_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
|
||||
friend
|
||||
basic_istream<_CharT, _Traits>&
|
||||
operator>>(basic_istream<_CharT, _Traits>& __is,
|
||||
mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __x);
|
||||
private:
|
||||
|
||||
@ -2384,13 +2386,13 @@ mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
|
||||
return __z ^ __rshift<__l>(__z);
|
||||
}
|
||||
|
||||
template <class _UI, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UI _Ap, size_t _Up, _UI _Dp, size_t _Sp,
|
||||
_UI _Bp, size_t _Tp, _UI _Cp, size_t _Lp, _UI _Fp>
|
||||
template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
|
||||
_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
|
||||
bool
|
||||
operator==(const mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __x,
|
||||
const mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __y)
|
||||
{
|
||||
if (__x.__i_ == __y.__i_)
|
||||
@ -2428,26 +2430,26 @@ operator==(const mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp,
|
||||
__x.__x_ + (_Np - (__y.__i_ + __j)));
|
||||
}
|
||||
|
||||
template <class _UI, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UI _Ap, size_t _Up, _UI _Dp, size_t _Sp,
|
||||
_UI _Bp, size_t _Tp, _UI _Cp, size_t _Lp, _UI _Fp>
|
||||
template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
|
||||
_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator!=(const mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __x,
|
||||
const mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __y)
|
||||
{
|
||||
return !(__x == __y);
|
||||
}
|
||||
|
||||
template <class _CharT, class _Traits,
|
||||
class _UI, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UI _Ap, size_t _Up, _UI _Dp, size_t _Sp,
|
||||
_UI _Bp, size_t _Tp, _UI _Cp, size_t _Lp, _UI _Fp>
|
||||
class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
|
||||
_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __os,
|
||||
const mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __x)
|
||||
{
|
||||
__save_flags<_CharT, _Traits> __lx(__os);
|
||||
@ -2463,17 +2465,17 @@ operator<<(basic_ostream<_CharT, _Traits>& __os,
|
||||
}
|
||||
|
||||
template <class _CharT, class _Traits,
|
||||
class _UI, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UI _Ap, size_t _Up, _UI _Dp, size_t _Sp,
|
||||
_UI _Bp, size_t _Tp, _UI _Cp, size_t _Lp, _UI _Fp>
|
||||
class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
|
||||
_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
|
||||
_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
|
||||
basic_istream<_CharT, _Traits>&
|
||||
operator>>(basic_istream<_CharT, _Traits>& __is,
|
||||
mersenne_twister_engine<_UI, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
|
||||
_Bp, _Tp, _Cp, _Lp, _Fp>& __x)
|
||||
{
|
||||
__save_flags<_CharT, _Traits> __lx(__is);
|
||||
__is.flags(ios_base::dec | ios_base::skipws);
|
||||
_UI __t[_Np];
|
||||
_UInt __t[_Np];
|
||||
for (size_t __i = 0; __i < _Np; ++__i)
|
||||
__is >> __t[__i];
|
||||
if (!__is.fail())
|
||||
@ -2501,30 +2503,30 @@ typedef mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
|
||||
template<class _UIntType, size_t __w, size_t __s, size_t __r>
|
||||
class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine;
|
||||
|
||||
template<class _UI, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
bool
|
||||
operator==(
|
||||
const subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x,
|
||||
const subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __y);
|
||||
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
|
||||
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
|
||||
|
||||
template<class _UI, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator!=(
|
||||
const subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x,
|
||||
const subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __y);
|
||||
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
|
||||
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
|
||||
|
||||
template <class _CharT, class _Traits,
|
||||
class _UI, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __os,
|
||||
const subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x);
|
||||
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
|
||||
|
||||
template <class _CharT, class _Traits,
|
||||
class _UI, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
basic_istream<_CharT, _Traits>&
|
||||
operator>>(basic_istream<_CharT, _Traits>& __is,
|
||||
subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x);
|
||||
subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
|
||||
|
||||
template<class _UIntType, size_t __w, size_t __s, size_t __r>
|
||||
class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine
|
||||
@ -2586,33 +2588,33 @@ public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
|
||||
|
||||
template<class _UI, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
friend
|
||||
bool
|
||||
operator==(
|
||||
const subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x,
|
||||
const subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __y);
|
||||
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
|
||||
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
|
||||
|
||||
template<class _UI, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
friend
|
||||
bool
|
||||
operator!=(
|
||||
const subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x,
|
||||
const subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __y);
|
||||
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
|
||||
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
|
||||
|
||||
template <class _CharT, class _Traits,
|
||||
class _UI, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
friend
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __os,
|
||||
const subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x);
|
||||
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
|
||||
|
||||
template <class _CharT, class _Traits,
|
||||
class _UI, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
friend
|
||||
basic_istream<_CharT, _Traits>&
|
||||
operator>>(basic_istream<_CharT, _Traits>& __is,
|
||||
subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x);
|
||||
subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
|
||||
|
||||
private:
|
||||
|
||||
@ -2711,11 +2713,11 @@ subtract_with_carry_engine<_UIntType, __w, __s, __r>::operator()()
|
||||
return __xr;
|
||||
}
|
||||
|
||||
template<class _UI, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
bool
|
||||
operator==(
|
||||
const subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x,
|
||||
const subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __y)
|
||||
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
|
||||
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y)
|
||||
{
|
||||
if (__x.__c_ != __y.__c_)
|
||||
return false;
|
||||
@ -2754,21 +2756,21 @@ operator==(
|
||||
__x.__x_ + (_Rp - (__y.__i_ + __j)));
|
||||
}
|
||||
|
||||
template<class _UI, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator!=(
|
||||
const subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x,
|
||||
const subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __y)
|
||||
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
|
||||
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y)
|
||||
{
|
||||
return !(__x == __y);
|
||||
}
|
||||
|
||||
template <class _CharT, class _Traits,
|
||||
class _UI, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __os,
|
||||
const subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x)
|
||||
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x)
|
||||
{
|
||||
__save_flags<_CharT, _Traits> __lx(__os);
|
||||
__os.flags(ios_base::dec | ios_base::left);
|
||||
@ -2784,14 +2786,14 @@ operator<<(basic_ostream<_CharT, _Traits>& __os,
|
||||
}
|
||||
|
||||
template <class _CharT, class _Traits,
|
||||
class _UI, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
|
||||
basic_istream<_CharT, _Traits>&
|
||||
operator>>(basic_istream<_CharT, _Traits>& __is,
|
||||
subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x)
|
||||
subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x)
|
||||
{
|
||||
__save_flags<_CharT, _Traits> __lx(__is);
|
||||
__is.flags(ios_base::dec | ios_base::skipws);
|
||||
_UI __t[_Rp+1];
|
||||
_UInt __t[_Rp+1];
|
||||
for (size_t __i = 0; __i < _Rp+1; ++__i)
|
||||
__is >> __t[__i];
|
||||
if (!__is.fail())
|
||||
@ -2986,13 +2988,13 @@ typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
|
||||
template<class _Engine, size_t __w, class _UIntType>
|
||||
class _LIBCPP_TEMPLATE_VIS independent_bits_engine
|
||||
{
|
||||
template <class _UI, _UI _R0, size_t _Wp, size_t _Mp>
|
||||
template <class _UInt, _UInt _R0, size_t _Wp, size_t _Mp>
|
||||
class __get_n
|
||||
{
|
||||
static _LIBCPP_CONSTEXPR const size_t _Dt = numeric_limits<_UI>::digits;
|
||||
static _LIBCPP_CONSTEXPR const size_t _Dt = numeric_limits<_UInt>::digits;
|
||||
static _LIBCPP_CONSTEXPR const size_t _Np = _Wp / _Mp + (_Wp % _Mp != 0);
|
||||
static _LIBCPP_CONSTEXPR const size_t _W0 = _Wp / _Np;
|
||||
static _LIBCPP_CONSTEXPR const _UI _Y0 = _W0 >= _Dt ? 0 : (_R0 >> _W0) << _W0;
|
||||
static _LIBCPP_CONSTEXPR const _UInt _Y0 = _W0 >= _Dt ? 0 : (_R0 >> _W0) << _W0;
|
||||
public:
|
||||
static _LIBCPP_CONSTEXPR const size_t value = _R0 - _Y0 > _Y0 / _Np ? _Np + 1 : _Np;
|
||||
};
|
||||
@ -3091,33 +3093,33 @@ public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
const _Engine& base() const _NOEXCEPT {return __e_;}
|
||||
|
||||
template<class _Eng, size_t _Wp, class _UI>
|
||||
template<class _Eng, size_t _Wp, class _UInt>
|
||||
friend
|
||||
bool
|
||||
operator==(
|
||||
const independent_bits_engine<_Eng, _Wp, _UI>& __x,
|
||||
const independent_bits_engine<_Eng, _Wp, _UI>& __y);
|
||||
const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
|
||||
const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
|
||||
|
||||
template<class _Eng, size_t _Wp, class _UI>
|
||||
template<class _Eng, size_t _Wp, class _UInt>
|
||||
friend
|
||||
bool
|
||||
operator!=(
|
||||
const independent_bits_engine<_Eng, _Wp, _UI>& __x,
|
||||
const independent_bits_engine<_Eng, _Wp, _UI>& __y);
|
||||
const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
|
||||
const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
|
||||
|
||||
template <class _CharT, class _Traits,
|
||||
class _Eng, size_t _Wp, class _UI>
|
||||
class _Eng, size_t _Wp, class _UInt>
|
||||
friend
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __os,
|
||||
const independent_bits_engine<_Eng, _Wp, _UI>& __x);
|
||||
const independent_bits_engine<_Eng, _Wp, _UInt>& __x);
|
||||
|
||||
template <class _CharT, class _Traits,
|
||||
class _Eng, size_t _Wp, class _UI>
|
||||
class _Eng, size_t _Wp, class _UInt>
|
||||
friend
|
||||
basic_istream<_CharT, _Traits>&
|
||||
operator>>(basic_istream<_CharT, _Traits>& __is,
|
||||
independent_bits_engine<_Eng, _Wp, _UI>& __x);
|
||||
independent_bits_engine<_Eng, _Wp, _UInt>& __x);
|
||||
|
||||
private:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@ -3179,40 +3181,40 @@ independent_bits_engine<_Engine, __w, _UIntType>::__eval(true_type)
|
||||
return _Sp;
|
||||
}
|
||||
|
||||
template<class _Eng, size_t _Wp, class _UI>
|
||||
template<class _Eng, size_t _Wp, class _UInt>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator==(
|
||||
const independent_bits_engine<_Eng, _Wp, _UI>& __x,
|
||||
const independent_bits_engine<_Eng, _Wp, _UI>& __y)
|
||||
const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
|
||||
const independent_bits_engine<_Eng, _Wp, _UInt>& __y)
|
||||
{
|
||||
return __x.base() == __y.base();
|
||||
}
|
||||
|
||||
template<class _Eng, size_t _Wp, class _UI>
|
||||
template<class _Eng, size_t _Wp, class _UInt>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator!=(
|
||||
const independent_bits_engine<_Eng, _Wp, _UI>& __x,
|
||||
const independent_bits_engine<_Eng, _Wp, _UI>& __y)
|
||||
const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
|
||||
const independent_bits_engine<_Eng, _Wp, _UInt>& __y)
|
||||
{
|
||||
return !(__x == __y);
|
||||
}
|
||||
|
||||
template <class _CharT, class _Traits,
|
||||
class _Eng, size_t _Wp, class _UI>
|
||||
class _Eng, size_t _Wp, class _UInt>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __os,
|
||||
const independent_bits_engine<_Eng, _Wp, _UI>& __x)
|
||||
const independent_bits_engine<_Eng, _Wp, _UInt>& __x)
|
||||
{
|
||||
return __os << __x.base();
|
||||
}
|
||||
|
||||
template <class _CharT, class _Traits,
|
||||
class _Eng, size_t _Wp, class _UI>
|
||||
class _Eng, size_t _Wp, class _UInt>
|
||||
basic_istream<_CharT, _Traits>&
|
||||
operator>>(basic_istream<_CharT, _Traits>& __is,
|
||||
independent_bits_engine<_Eng, _Wp, _UI>& __x)
|
||||
independent_bits_engine<_Eng, _Wp, _UInt>& __x)
|
||||
{
|
||||
_Eng __e;
|
||||
__is >> __e;
|
||||
@ -6736,4 +6738,6 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_RANDOM
|
||||
|
@ -83,12 +83,14 @@ typedef ratio<1000000000000000000000000, 1> yotta; // not supported
|
||||
#include <climits>
|
||||
#include <type_traits>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
// __static_gcd
|
||||
@ -520,4 +522,6 @@ template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_greater_equal_v
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_RATIO
|
||||
|
@ -765,12 +765,14 @@ typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
|
||||
#include <vector>
|
||||
#include <deque>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
namespace regex_constants
|
||||
@ -6562,4 +6564,6 @@ regex_replace(const _CharT* __s,
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_REGEX
|
||||
|
@ -125,12 +125,14 @@ template <class Mutex>
|
||||
|
||||
#include <__config>
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
#if _LIBCPP_STD_VER > 11 || defined(_LIBCPP_BUILDING_SHARED_MUTEX)
|
||||
|
||||
#include <__mutex_base>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
@ -500,4 +502,6 @@ _LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
#endif // _LIBCPP_STD_VER > 11
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_SHARED_MUTEX
|
||||
|
@ -175,12 +175,14 @@ typedef basic_stringstream<wchar_t> wstringstream;
|
||||
#include <istream>
|
||||
#include <string>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
// basic_stringbuf
|
||||
@ -970,4 +972,6 @@ basic_stringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s)
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_SSTREAM
|
||||
|
@ -61,9 +61,9 @@ class _LIBCPP_HIDDEN __libcpp_refstring
|
||||
|
||||
bool __uses_refcount() const;
|
||||
public:
|
||||
explicit __libcpp_refstring(const char* msg);
|
||||
__libcpp_refstring(const __libcpp_refstring& s) _NOEXCEPT;
|
||||
__libcpp_refstring& operator=(const __libcpp_refstring& s) _NOEXCEPT;
|
||||
explicit __libcpp_refstring(const char* __msg);
|
||||
__libcpp_refstring(const __libcpp_refstring& __s) _NOEXCEPT;
|
||||
__libcpp_refstring& operator=(const __libcpp_refstring& __s) _NOEXCEPT;
|
||||
~__libcpp_refstring();
|
||||
|
||||
const char* c_str() const _NOEXCEPT {return __imp_;}
|
||||
|
@ -110,10 +110,9 @@ void perror(const char* s);
|
||||
#ifdef __cplusplus
|
||||
|
||||
// snprintf
|
||||
#if defined(_LIBCPP_MSVCRT)
|
||||
#if defined(_LIBCPP_MSVCRT_LIKE)
|
||||
extern "C" {
|
||||
int vasprintf(char **sptr, const char *__restrict fmt, va_list ap);
|
||||
int asprintf(char **sptr, const char *__restrict fmt, ...);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
@ -116,6 +116,9 @@ protected:
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _CharT, class _Traits>
|
||||
@ -486,4 +489,6 @@ _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ios<wchar_t
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_STEAMBUF
|
||||
|
@ -484,14 +484,16 @@ basic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++1
|
||||
#include <cstdint>
|
||||
#endif
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#include <__debug>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
// fpos
|
||||
@ -899,7 +901,7 @@ public:
|
||||
void resize(size_type __n, value_type __c);
|
||||
_LIBCPP_INLINE_VISIBILITY void resize(size_type __n) {resize(__n, value_type());}
|
||||
|
||||
void reserve(size_type res_arg = 0);
|
||||
void reserve(size_type __res_arg = 0);
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void shrink_to_fit() _NOEXCEPT {reserve();}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@ -985,9 +987,9 @@ public:
|
||||
basic_string& assign(const basic_string& __str) { return *this = __str; }
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_string& assign(basic_string&& str)
|
||||
basic_string& assign(basic_string&& __str)
|
||||
_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
|
||||
{*this = _VSTD::move(str); return *this;}
|
||||
{*this = _VSTD::move(__str); return *this;}
|
||||
#endif
|
||||
basic_string& assign(const basic_string& __str, size_type __pos, size_type __n=npos);
|
||||
template <class _Tp>
|
||||
@ -997,7 +999,7 @@ public:
|
||||
__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
|
||||
basic_string&
|
||||
>::type
|
||||
assign(const _Tp & __t, size_type pos, size_type n=npos);
|
||||
assign(const _Tp & __t, size_type __pos, size_type __n=npos);
|
||||
basic_string& assign(const value_type* __s, size_type __n);
|
||||
basic_string& assign(const value_type* __s);
|
||||
basic_string& assign(size_type __n, value_type __c);
|
||||
@ -4041,4 +4043,6 @@ _LIBCPP_EXTERN_TEMPLATE(string operator+<char, char_traits<char>, allocator<char
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_STRING
|
||||
|
@ -166,7 +166,6 @@ namespace std {
|
||||
*/
|
||||
|
||||
#include <__config>
|
||||
|
||||
#include <__string>
|
||||
#include <algorithm>
|
||||
#include <iterator>
|
||||
@ -178,6 +177,10 @@ namespace std {
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template<class _CharT, class _Traits = char_traits<_CharT> >
|
||||
@ -353,9 +356,9 @@ public:
|
||||
|
||||
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
||||
int compare( size_type __pos1, size_type __n1,
|
||||
basic_string_view _sv, size_type __pos2, size_type __n2) const
|
||||
basic_string_view __sv, size_type __pos2, size_type __n2) const
|
||||
{
|
||||
return substr(__pos1, __n1).compare(_sv.substr(__pos2, __n2));
|
||||
return substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
|
||||
}
|
||||
|
||||
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
||||
@ -784,4 +787,6 @@ inline namespace literals
|
||||
#endif
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_STRING_VIEW
|
||||
|
@ -105,6 +105,9 @@ void sleep_for(const chrono::duration<Rep, Period>& rel_time);
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
#define __STDCPP_THREADS__ __cplusplus
|
||||
|
||||
#ifdef _LIBCPP_HAS_NO_THREADS
|
||||
@ -476,4 +479,6 @@ _LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
#endif // !_LIBCPP_HAS_NO_THREADS
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_THREAD
|
||||
|
@ -169,7 +169,7 @@ void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
|
||||
template <size_t _Ip, class _Hp, bool>
|
||||
class __tuple_leaf
|
||||
{
|
||||
_Hp value;
|
||||
_Hp __value_;
|
||||
|
||||
template <class _Tp>
|
||||
static constexpr bool __can_bind_reference() {
|
||||
@ -188,28 +188,28 @@ class __tuple_leaf
|
||||
__tuple_leaf& operator=(const __tuple_leaf&);
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
|
||||
_NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : value()
|
||||
_NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : __value_()
|
||||
{static_assert(!is_reference<_Hp>::value,
|
||||
"Attempted to default construct a reference element in a tuple");}
|
||||
|
||||
template <class _Alloc>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__tuple_leaf(integral_constant<int, 0>, const _Alloc&)
|
||||
: value()
|
||||
: __value_()
|
||||
{static_assert(!is_reference<_Hp>::value,
|
||||
"Attempted to default construct a reference element in a tuple");}
|
||||
|
||||
template <class _Alloc>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
|
||||
: value(allocator_arg_t(), __a)
|
||||
: __value_(allocator_arg_t(), __a)
|
||||
{static_assert(!is_reference<_Hp>::value,
|
||||
"Attempted to default construct a reference element in a tuple");}
|
||||
|
||||
template <class _Alloc>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
|
||||
: value(__a)
|
||||
: __value_(__a)
|
||||
{static_assert(!is_reference<_Hp>::value,
|
||||
"Attempted to default construct a reference element in a tuple");}
|
||||
|
||||
@ -223,28 +223,28 @@ public:
|
||||
>
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||||
explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
|
||||
: value(_VSTD::forward<_Tp>(__t))
|
||||
: __value_(_VSTD::forward<_Tp>(__t))
|
||||
{static_assert(__can_bind_reference<_Tp>(),
|
||||
"Attempted to construct a reference element in a tuple with an rvalue");}
|
||||
|
||||
template <class _Tp, class _Alloc>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
|
||||
: value(_VSTD::forward<_Tp>(__t))
|
||||
: __value_(_VSTD::forward<_Tp>(__t))
|
||||
{static_assert(__can_bind_reference<_Tp>(),
|
||||
"Attempted to construct a reference element in a tuple with an rvalue");}
|
||||
|
||||
template <class _Tp, class _Alloc>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
|
||||
: value(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
|
||||
: __value_(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
|
||||
{static_assert(!is_reference<_Hp>::value,
|
||||
"Attempted to uses-allocator construct a reference element in a tuple");}
|
||||
|
||||
template <class _Tp, class _Alloc>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
|
||||
: value(_VSTD::forward<_Tp>(__t), __a)
|
||||
: __value_(_VSTD::forward<_Tp>(__t), __a)
|
||||
{static_assert(!is_reference<_Hp>::value,
|
||||
"Attempted to uses-allocator construct a reference element in a tuple");}
|
||||
|
||||
@ -256,7 +256,7 @@ public:
|
||||
__tuple_leaf&
|
||||
operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
|
||||
{
|
||||
value = _VSTD::forward<_Tp>(__t);
|
||||
__value_ = _VSTD::forward<_Tp>(__t);
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -267,8 +267,8 @@ public:
|
||||
return 0;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Hp& get() _NOEXCEPT {return value;}
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return value;}
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Hp& get() _NOEXCEPT {return __value_;}
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return __value_;}
|
||||
};
|
||||
|
||||
template <size_t _Ip, class _Hp>
|
||||
@ -473,9 +473,9 @@ struct _LIBCPP_DECLSPEC_EMPTY_BASES __tuple_impl<__tuple_indices<_Indx...>, _Tp.
|
||||
template <class ..._Tp>
|
||||
class _LIBCPP_TEMPLATE_VIS tuple
|
||||
{
|
||||
typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> base;
|
||||
typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> _BaseT;
|
||||
|
||||
base base_;
|
||||
_BaseT __base_;
|
||||
|
||||
#if defined(_LIBCPP_ENABLE_TUPLE_IMPLICIT_REDUCED_ARITY_EXTENSION)
|
||||
static constexpr bool _EnableImplicitReducedArityExtension = true;
|
||||
@ -628,7 +628,7 @@ public:
|
||||
>::type>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
tuple(_AllocArgT, _Alloc const& __a)
|
||||
: base_(allocator_arg_t(), __a,
|
||||
: __base_(allocator_arg_t(), __a,
|
||||
__tuple_indices<>(), __tuple_types<>(),
|
||||
typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
|
||||
__tuple_types<_Tp...>()) {}
|
||||
@ -644,7 +644,7 @@ public:
|
||||
>
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||||
tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value))
|
||||
: base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
|
||||
: __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
|
||||
typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
|
||||
typename __make_tuple_indices<0>::type(),
|
||||
typename __make_tuple_types<tuple, 0>::type(),
|
||||
@ -662,7 +662,7 @@ public:
|
||||
>
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||||
explicit tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value))
|
||||
: base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
|
||||
: __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
|
||||
typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
|
||||
typename __make_tuple_indices<0>::type(),
|
||||
typename __make_tuple_types<tuple, 0>::type(),
|
||||
@ -680,7 +680,7 @@ public:
|
||||
>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
|
||||
: base_(allocator_arg_t(), __a,
|
||||
: __base_(allocator_arg_t(), __a,
|
||||
typename __make_tuple_indices<sizeof...(_Tp)>::type(),
|
||||
typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
|
||||
typename __make_tuple_indices<0>::type(),
|
||||
@ -700,7 +700,7 @@ public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit
|
||||
tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
|
||||
: base_(allocator_arg_t(), __a,
|
||||
: __base_(allocator_arg_t(), __a,
|
||||
typename __make_tuple_indices<sizeof...(_Tp)>::type(),
|
||||
typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
|
||||
typename __make_tuple_indices<0>::type(),
|
||||
@ -727,7 +727,7 @@ public:
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||||
tuple(_Up&&... __u)
|
||||
_NOEXCEPT_((
|
||||
is_nothrow_constructible<base,
|
||||
is_nothrow_constructible<_BaseT,
|
||||
typename __make_tuple_indices<sizeof...(_Up)>::type,
|
||||
typename __make_tuple_types<tuple, sizeof...(_Up)>::type,
|
||||
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type,
|
||||
@ -735,7 +735,7 @@ public:
|
||||
_Up...
|
||||
>::value
|
||||
))
|
||||
: base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
|
||||
: __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
|
||||
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
|
||||
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
|
||||
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
|
||||
@ -760,7 +760,7 @@ public:
|
||||
explicit
|
||||
tuple(_Up&&... __u)
|
||||
_NOEXCEPT_((
|
||||
is_nothrow_constructible<base,
|
||||
is_nothrow_constructible<_BaseT,
|
||||
typename __make_tuple_indices<sizeof...(_Up)>::type,
|
||||
typename __make_tuple_types<tuple, sizeof...(_Up)>::type,
|
||||
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type,
|
||||
@ -768,7 +768,7 @@ public:
|
||||
_Up...
|
||||
>::value
|
||||
))
|
||||
: base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
|
||||
: __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
|
||||
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
|
||||
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
|
||||
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
|
||||
@ -786,7 +786,7 @@ public:
|
||||
>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
|
||||
: base_(allocator_arg_t(), __a,
|
||||
: __base_(allocator_arg_t(), __a,
|
||||
typename __make_tuple_indices<sizeof...(_Up)>::type(),
|
||||
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
|
||||
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
|
||||
@ -806,7 +806,7 @@ public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit
|
||||
tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
|
||||
: base_(allocator_arg_t(), __a,
|
||||
: __base_(allocator_arg_t(), __a,
|
||||
typename __make_tuple_indices<sizeof...(_Up)>::type(),
|
||||
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
|
||||
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
|
||||
@ -824,8 +824,8 @@ public:
|
||||
>::type = false
|
||||
>
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||||
tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value))
|
||||
: base_(_VSTD::forward<_Tuple>(__t)) {}
|
||||
tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<_BaseT, _Tuple>::value))
|
||||
: __base_(_VSTD::forward<_Tuple>(__t)) {}
|
||||
|
||||
template <class _Tuple,
|
||||
typename enable_if
|
||||
@ -839,8 +839,8 @@ public:
|
||||
>
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||||
explicit
|
||||
tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value))
|
||||
: base_(_VSTD::forward<_Tuple>(__t)) {}
|
||||
tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<_BaseT, _Tuple>::value))
|
||||
: __base_(_VSTD::forward<_Tuple>(__t)) {}
|
||||
|
||||
template <class _Alloc, class _Tuple,
|
||||
typename enable_if
|
||||
@ -853,7 +853,7 @@ public:
|
||||
>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
|
||||
: base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
|
||||
: __base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
|
||||
|
||||
template <class _Alloc, class _Tuple,
|
||||
typename enable_if
|
||||
@ -867,7 +867,7 @@ public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit
|
||||
tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
|
||||
: base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
|
||||
: __base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
|
||||
|
||||
using _CanCopyAssign = __all<is_copy_assignable<_Tp>::value...>;
|
||||
using _CanMoveAssign = __all<is_move_assignable<_Tp>::value...>;
|
||||
@ -876,7 +876,7 @@ public:
|
||||
tuple& operator=(typename conditional<_CanCopyAssign::value, tuple, __nat>::type const& __t)
|
||||
_NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
|
||||
{
|
||||
base_.operator=(__t.base_);
|
||||
__base_.operator=(__t.__base_);
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -884,7 +884,7 @@ public:
|
||||
tuple& operator=(typename conditional<_CanMoveAssign::value, tuple, __nat>::type&& __t)
|
||||
_NOEXCEPT_((__all<is_nothrow_move_assignable<_Tp>::value...>::value))
|
||||
{
|
||||
base_.operator=(static_cast<base&&>(__t.base_));
|
||||
__base_.operator=(static_cast<_BaseT&&>(__t.__base_));
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -896,15 +896,15 @@ public:
|
||||
>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
tuple&
|
||||
operator=(_Tuple&& __t) _NOEXCEPT_((is_nothrow_assignable<base&, _Tuple>::value))
|
||||
operator=(_Tuple&& __t) _NOEXCEPT_((is_nothrow_assignable<_BaseT&, _Tuple>::value))
|
||||
{
|
||||
base_.operator=(_VSTD::forward<_Tuple>(__t));
|
||||
__base_.operator=(_VSTD::forward<_Tuple>(__t));
|
||||
return *this;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
|
||||
{base_.swap(__t.base_);}
|
||||
{__base_.swap(__t.__base_);}
|
||||
};
|
||||
|
||||
template <>
|
||||
@ -948,7 +948,7 @@ typename tuple_element<_Ip, tuple<_Tp...> >::type&
|
||||
get(tuple<_Tp...>& __t) _NOEXCEPT
|
||||
{
|
||||
typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
|
||||
return static_cast<__tuple_leaf<_Ip, type>&>(__t.base_).get();
|
||||
return static_cast<__tuple_leaf<_Ip, type>&>(__t.__base_).get();
|
||||
}
|
||||
|
||||
template <size_t _Ip, class ..._Tp>
|
||||
@ -957,7 +957,7 @@ const typename tuple_element<_Ip, tuple<_Tp...> >::type&
|
||||
get(const tuple<_Tp...>& __t) _NOEXCEPT
|
||||
{
|
||||
typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
|
||||
return static_cast<const __tuple_leaf<_Ip, type>&>(__t.base_).get();
|
||||
return static_cast<const __tuple_leaf<_Ip, type>&>(__t.__base_).get();
|
||||
}
|
||||
|
||||
template <size_t _Ip, class ..._Tp>
|
||||
@ -967,7 +967,7 @@ get(tuple<_Tp...>&& __t) _NOEXCEPT
|
||||
{
|
||||
typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
|
||||
return static_cast<type&&>(
|
||||
static_cast<__tuple_leaf<_Ip, type>&&>(__t.base_).get());
|
||||
static_cast<__tuple_leaf<_Ip, type>&&>(__t.__base_).get());
|
||||
}
|
||||
|
||||
template <size_t _Ip, class ..._Tp>
|
||||
@ -977,7 +977,7 @@ get(const tuple<_Tp...>&& __t) _NOEXCEPT
|
||||
{
|
||||
typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
|
||||
return static_cast<const type&&>(
|
||||
static_cast<const __tuple_leaf<_Ip, type>&&>(__t.base_).get());
|
||||
static_cast<const __tuple_leaf<_Ip, type>&&>(__t.__base_).get());
|
||||
}
|
||||
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
|
@ -347,12 +347,14 @@ template <class T> unspecified2 end(const valarray<T>& v);
|
||||
#include <functional>
|
||||
#include <new>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template<class _Tp> class _LIBCPP_TEMPLATE_VIS valarray;
|
||||
@ -4865,4 +4867,6 @@ end(const valarray<_Tp>& __v)
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_VALARRAY
|
||||
|
@ -275,14 +275,16 @@ void swap(vector<T,Allocator>& x, vector<T,Allocator>& y)
|
||||
#include <__split_buffer>
|
||||
#include <__functional_base>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#include <__debug>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_PUSH_MACROS
|
||||
#include <__undef_macros>
|
||||
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <bool>
|
||||
@ -3357,4 +3359,6 @@ swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y)
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
_LIBCPP_POP_MACROS
|
||||
|
||||
#endif // _LIBCPP_VECTOR
|
||||
|
@ -166,7 +166,7 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(__cplusplus) && defined(_LIBCPP_MSVCRT)
|
||||
#if defined(__cplusplus) && defined(_LIBCPP_MSVCRT_LIKE)
|
||||
extern "C" {
|
||||
size_t mbsnrtowcs(wchar_t *__restrict dst, const char **__restrict src,
|
||||
size_t nmc, size_t len, mbstate_t *__restrict ps);
|
||||
|
@ -37,7 +37,7 @@
|
||||
#if defined(_LIBCPP_WIN32API)
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#define VC_EXTRA_LEAN
|
||||
#include <Windows.h>
|
||||
#include <windows.h>
|
||||
#if _WIN32_WINNT >= _WIN32_WINNT_WIN8
|
||||
#include <winapifamily.h>
|
||||
#endif
|
||||
|
@ -14,6 +14,7 @@
|
||||
#include "condition_variable"
|
||||
#include "thread"
|
||||
#include "system_error"
|
||||
#include "__undef_macros"
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
@ -22,6 +22,7 @@
|
||||
#include "new"
|
||||
#include "streambuf"
|
||||
#include "string"
|
||||
#include "__undef_macros"
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
@ -36,6 +36,7 @@
|
||||
#endif
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include "__undef_macros"
|
||||
|
||||
// On Linux, wint_t and wchar_t have different signed-ness, and this causes
|
||||
// lots of noise in the build log, but no bugs that I know of.
|
||||
|
@ -12,6 +12,7 @@
|
||||
#include "limits"
|
||||
#include "system_error"
|
||||
#include "include/atomic_support.h"
|
||||
#include "__undef_macros"
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
#ifndef _LIBCPP_HAS_NO_THREADS
|
||||
|
@ -183,7 +183,7 @@ operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
|
||||
if (static_cast<size_t>(alignment) < sizeof(void*))
|
||||
alignment = std::align_val_t(sizeof(void*));
|
||||
void* p;
|
||||
#if defined(_LIBCPP_MSVCRT)
|
||||
#if defined(_LIBCPP_MSVCRT_LIKE)
|
||||
while ((p = _aligned_malloc(size, static_cast<size_t>(alignment))) == nullptr)
|
||||
#else
|
||||
while (::posix_memalign(&p, static_cast<size_t>(alignment), size) != 0)
|
||||
@ -256,7 +256,7 @@ void
|
||||
operator delete(void* ptr, std::align_val_t) _NOEXCEPT
|
||||
{
|
||||
if (ptr)
|
||||
#if defined(_LIBCPP_MSVCRT)
|
||||
#if defined(_LIBCPP_MSVCRT_LIKE)
|
||||
::_aligned_free(ptr);
|
||||
#else
|
||||
::free(ptr);
|
||||
|
@ -13,6 +13,7 @@
|
||||
#include "cstring"
|
||||
#include "cstdlib"
|
||||
#include "__debug"
|
||||
#include "__undef_macros"
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
@ -65,7 +65,7 @@ constexpr size_t strerror_buff_size = 1024;
|
||||
|
||||
string do_strerror_r(int ev);
|
||||
|
||||
#if defined(_LIBCPP_MSVCRT)
|
||||
#if defined(_LIBCPP_MSVCRT_LIKE)
|
||||
string do_strerror_r(int ev) {
|
||||
char buffer[strerror_buff_size];
|
||||
if (::strerror_s(buffer, strerror_buff_size, ev) == 0)
|
||||
|
@ -34,7 +34,7 @@
|
||||
|
||||
#if defined(_LIBCPP_WIN32API)
|
||||
#include <windows.h>
|
||||
#endif // defined(_LIBCPP_WIN32API)
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
@ -454,6 +454,9 @@ class TargetTransformInfo {
|
||||
/// \brief Don't restrict interleaved unrolling to small loops.
|
||||
bool enableAggressiveInterleaving(bool LoopHasReductions) const;
|
||||
|
||||
/// \brief Enable inline expansion of memcmp
|
||||
bool expandMemCmp(Instruction *I, unsigned &MaxLoadSize) const;
|
||||
|
||||
/// \brief Enable matching of interleaved access groups.
|
||||
bool enableInterleavedAccessVectorization() const;
|
||||
|
||||
@ -828,6 +831,7 @@ class TargetTransformInfo::Concept {
|
||||
unsigned VF) = 0;
|
||||
virtual bool supportsEfficientVectorElementLoadStore() = 0;
|
||||
virtual bool enableAggressiveInterleaving(bool LoopHasReductions) = 0;
|
||||
virtual bool expandMemCmp(Instruction *I, unsigned &MaxLoadSize) = 0;
|
||||
virtual bool enableInterleavedAccessVectorization() = 0;
|
||||
virtual bool isFPVectorizationPotentiallyUnsafe() = 0;
|
||||
virtual bool allowsMisalignedMemoryAccesses(LLVMContext &Context,
|
||||
@ -1047,6 +1051,9 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept {
|
||||
bool enableAggressiveInterleaving(bool LoopHasReductions) override {
|
||||
return Impl.enableAggressiveInterleaving(LoopHasReductions);
|
||||
}
|
||||
bool expandMemCmp(Instruction *I, unsigned &MaxLoadSize) override {
|
||||
return Impl.expandMemCmp(I, MaxLoadSize);
|
||||
}
|
||||
bool enableInterleavedAccessVectorization() override {
|
||||
return Impl.enableInterleavedAccessVectorization();
|
||||
}
|
||||
|
@ -274,6 +274,8 @@ class TargetTransformInfoImplBase {
|
||||
|
||||
bool enableAggressiveInterleaving(bool LoopHasReductions) { return false; }
|
||||
|
||||
bool expandMemCmp(Instruction *I, unsigned &MaxLoadSize) { return false; }
|
||||
|
||||
bool enableInterleavedAccessVectorization() { return false; }
|
||||
|
||||
bool isFPVectorizationPotentiallyUnsafe() { return false; }
|
||||
|
@ -85,6 +85,8 @@ template <typename T> class ArrayRef;
|
||||
const Instruction *CxtI = nullptr,
|
||||
const DominatorTree *DT = nullptr);
|
||||
|
||||
bool isOnlyUsedInZeroEqualityComparison(const Instruction *CxtI);
|
||||
|
||||
/// Return true if the given value is known to be non-zero when defined. For
|
||||
/// vectors, return true if every element is known to be non-zero when
|
||||
/// defined. For pointers, if the context instruction and dominator tree are
|
||||
|
@ -396,7 +396,7 @@ class RegisterBankInfo {
|
||||
mutable DenseMap<unsigned, std::unique_ptr<const InstructionMapping>>
|
||||
MapOfInstructionMappings;
|
||||
|
||||
/// Create a RegisterBankInfo that can accomodate up to \p NumRegBanks
|
||||
/// Create a RegisterBankInfo that can accommodate up to \p NumRegBanks
|
||||
/// RegisterBank instances.
|
||||
RegisterBankInfo(RegisterBank **RegBanks, unsigned NumRegBanks);
|
||||
|
||||
|
@ -410,12 +410,22 @@ namespace ISD {
|
||||
/// then the result type must also be a vector type.
|
||||
SETCC,
|
||||
|
||||
/// Like SetCC, ops #0 and #1 are the LHS and RHS operands to compare, but
|
||||
/// Like SetCC, ops #0 and #1 are the LHS and RHS operands to compare, and
|
||||
/// op #2 is a *carry value*. This operator checks the result of
|
||||
/// "LHS - RHS - Carry", and can be used to compare two wide integers:
|
||||
/// (setcce lhshi rhshi (subc lhslo rhslo) cc). Only valid for integers.
|
||||
/// FIXME: This node is deprecated in favor of SETCCCARRY.
|
||||
/// It is kept around for now to provide a smooth transition path
|
||||
/// toward the use of SETCCCARRY and will eventually be removed.
|
||||
SETCCE,
|
||||
|
||||
/// Like SetCC, ops #0 and #1 are the LHS and RHS operands to compare, but
|
||||
/// op #2 is a boolean indicating if there is an incoming carry. This
|
||||
/// operator checks the result of "LHS - RHS - Carry", and can be used to
|
||||
/// compare two wide integers: (setcce lhshi rhshi (subc lhslo rhslo) cc).
|
||||
/// Only valid for integers.
|
||||
SETCCCARRY,
|
||||
|
||||
/// SHL_PARTS/SRA_PARTS/SRL_PARTS - These operators are used for expanded
|
||||
/// integer shift operations. The operation ordering is:
|
||||
/// [Lo,Hi] = op [LoLHS,HiLHS], Amt
|
||||
|
@ -381,7 +381,6 @@ struct MachineFunction {
|
||||
StringRef Name;
|
||||
unsigned Alignment = 0;
|
||||
bool ExposesReturnsTwice = false;
|
||||
bool NoVRegs;
|
||||
// GISel MachineFunctionProperties.
|
||||
bool Legalized = false;
|
||||
bool RegBankSelected = false;
|
||||
@ -406,7 +405,6 @@ template <> struct MappingTraits<MachineFunction> {
|
||||
YamlIO.mapRequired("name", MF.Name);
|
||||
YamlIO.mapOptional("alignment", MF.Alignment);
|
||||
YamlIO.mapOptional("exposesReturnsTwice", MF.ExposesReturnsTwice);
|
||||
YamlIO.mapOptional("noVRegs", MF.NoVRegs);
|
||||
YamlIO.mapOptional("legalized", MF.Legalized);
|
||||
YamlIO.mapOptional("regBankSelected", MF.RegBankSelected);
|
||||
YamlIO.mapOptional("selected", MF.Selected);
|
||||
|
@ -335,6 +335,9 @@ class MachineBasicBlock
|
||||
return make_range(livein_begin(), livein_end());
|
||||
}
|
||||
|
||||
/// Remove entry from the livein set and return iterator to the next.
|
||||
livein_iterator removeLiveIn(livein_iterator I);
|
||||
|
||||
/// Get the clobber mask for the start of this basic block. Funclets use this
|
||||
/// to prevent register allocation across funclet transitions.
|
||||
const uint32_t *getBeginClobberMask(const TargetRegisterInfo *TRI) const;
|
||||
|
@ -1,4 +1,4 @@
|
||||
//===-- CodeGen/MachineConstantPool.h - Abstract Constant Pool --*- C++ -*-===//
|
||||
//===- CodeGen/MachineConstantPool.h - Abstract Constant Pool ---*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -18,29 +18,28 @@
|
||||
|
||||
#include "llvm/ADT/DenseSet.h"
|
||||
#include "llvm/MC/SectionKind.h"
|
||||
#include <cassert>
|
||||
#include <climits>
|
||||
#include <vector>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
class Constant;
|
||||
class FoldingSetNodeID;
|
||||
class DataLayout;
|
||||
class TargetMachine;
|
||||
class Type;
|
||||
class FoldingSetNodeID;
|
||||
class MachineConstantPool;
|
||||
class raw_ostream;
|
||||
class Type;
|
||||
|
||||
/// Abstract base class for all machine specific constantpool value subclasses.
|
||||
///
|
||||
class MachineConstantPoolValue {
|
||||
virtual void anchor();
|
||||
|
||||
Type *Ty;
|
||||
|
||||
public:
|
||||
explicit MachineConstantPoolValue(Type *ty) : Ty(ty) {}
|
||||
virtual ~MachineConstantPoolValue() {}
|
||||
virtual ~MachineConstantPoolValue() = default;
|
||||
|
||||
/// getType - get type of this MachineConstantPoolValue.
|
||||
///
|
||||
@ -81,6 +80,7 @@ class MachineConstantPoolEntry {
|
||||
: Alignment(A) {
|
||||
Val.ConstVal = V;
|
||||
}
|
||||
|
||||
MachineConstantPoolEntry(MachineConstantPoolValue *V, unsigned A)
|
||||
: Alignment(A) {
|
||||
Val.MachineCPVal = V;
|
||||
@ -153,13 +153,12 @@ class MachineConstantPool {
|
||||
|
||||
/// print - Used by the MachineFunction printer to print information about
|
||||
/// constant pool objects. Implemented in MachineFunction.cpp
|
||||
///
|
||||
void print(raw_ostream &OS) const;
|
||||
|
||||
/// dump - Call print(cerr) to be called from the debugger.
|
||||
void dump() const;
|
||||
};
|
||||
|
||||
} // End llvm namespace
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_CODEGEN_MACHINECONSTANTPOOL_H
|
||||
|
@ -1,4 +1,4 @@
|
||||
//===-- llvm/CodeGen/MachineFunction.h --------------------------*- C++ -*-===//
|
||||
//===- llvm/CodeGen/MachineFunction.h ---------------------------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -18,38 +18,61 @@
|
||||
#ifndef LLVM_CODEGEN_MACHINEFUNCTION_H
|
||||
#define LLVM_CODEGEN_MACHINEFUNCTION_H
|
||||
|
||||
#include "llvm/ADT/ArrayRef.h"
|
||||
#include "llvm/ADT/BitVector.h"
|
||||
#include "llvm/ADT/DenseMap.h"
|
||||
#include "llvm/ADT/GraphTraits.h"
|
||||
#include "llvm/ADT/ilist.h"
|
||||
#include "llvm/ADT/iterator.h"
|
||||
#include "llvm/ADT/Optional.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/Analysis/EHPersonalities.h"
|
||||
#include "llvm/CodeGen/MachineBasicBlock.h"
|
||||
#include "llvm/CodeGen/MachineInstr.h"
|
||||
#include "llvm/CodeGen/MachineMemOperand.h"
|
||||
#include "llvm/IR/DebugLoc.h"
|
||||
#include "llvm/IR/Instructions.h"
|
||||
#include "llvm/IR/Metadata.h"
|
||||
#include "llvm/MC/MCDwarf.h"
|
||||
#include "llvm/MC/MCSymbol.h"
|
||||
#include "llvm/Support/Allocator.h"
|
||||
#include "llvm/Support/ArrayRecycler.h"
|
||||
#include "llvm/Support/AtomicOrdering.h"
|
||||
#include "llvm/Support/Compiler.h"
|
||||
#include "llvm/Support/ErrorHandling.h"
|
||||
#include "llvm/Support/Recycler.h"
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
class Value;
|
||||
class BasicBlock;
|
||||
class BlockAddress;
|
||||
class DataLayout;
|
||||
class DIExpression;
|
||||
class DILocalVariable;
|
||||
class DILocation;
|
||||
class Function;
|
||||
class GCModuleInfo;
|
||||
class MachineRegisterInfo;
|
||||
class MachineFrameInfo;
|
||||
class GlobalValue;
|
||||
class MachineConstantPool;
|
||||
class MachineFrameInfo;
|
||||
class MachineFunction;
|
||||
class MachineJumpTableInfo;
|
||||
class MachineModuleInfo;
|
||||
class MachineRegisterInfo;
|
||||
class MCContext;
|
||||
class MCInstrDesc;
|
||||
class Pass;
|
||||
class PseudoSourceValueManager;
|
||||
class raw_ostream;
|
||||
class SlotIndexes;
|
||||
class TargetMachine;
|
||||
class TargetSubtargetInfo;
|
||||
class TargetRegisterClass;
|
||||
struct MachinePointerInfo;
|
||||
class TargetSubtargetInfo;
|
||||
struct WinEHFuncInfo;
|
||||
|
||||
template <> struct ilist_alloc_traits<MachineBasicBlock> {
|
||||
@ -137,27 +160,33 @@ class MachineFunctionProperties {
|
||||
bool hasProperty(Property P) const {
|
||||
return Properties[static_cast<unsigned>(P)];
|
||||
}
|
||||
|
||||
MachineFunctionProperties &set(Property P) {
|
||||
Properties.set(static_cast<unsigned>(P));
|
||||
return *this;
|
||||
}
|
||||
|
||||
MachineFunctionProperties &reset(Property P) {
|
||||
Properties.reset(static_cast<unsigned>(P));
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// Reset all the properties.
|
||||
MachineFunctionProperties &reset() {
|
||||
Properties.reset();
|
||||
return *this;
|
||||
}
|
||||
|
||||
MachineFunctionProperties &set(const MachineFunctionProperties &MFP) {
|
||||
Properties |= MFP.Properties;
|
||||
return *this;
|
||||
}
|
||||
|
||||
MachineFunctionProperties &reset(const MachineFunctionProperties &MFP) {
|
||||
Properties.reset(MFP.Properties);
|
||||
return *this;
|
||||
}
|
||||
|
||||
// Returns true if all properties set in V (i.e. required by a pass) are set
|
||||
// in this.
|
||||
bool verifyRequiredProperties(const MachineFunctionProperties &V) const {
|
||||
@ -180,18 +209,17 @@ struct SEHHandler {
|
||||
const BlockAddress *RecoverBA;
|
||||
};
|
||||
|
||||
|
||||
/// This structure is used to retain landing pad info for the current function.
|
||||
struct LandingPadInfo {
|
||||
MachineBasicBlock *LandingPadBlock; // Landing pad block.
|
||||
SmallVector<MCSymbol *, 1> BeginLabels; // Labels prior to invoke.
|
||||
SmallVector<MCSymbol *, 1> EndLabels; // Labels after invoke.
|
||||
SmallVector<SEHHandler, 1> SEHHandlers; // SEH handlers active at this lpad.
|
||||
MCSymbol *LandingPadLabel; // Label at beginning of landing pad.
|
||||
MCSymbol *LandingPadLabel = nullptr; // Label at beginning of landing pad.
|
||||
std::vector<int> TypeIds; // List of type ids (filters negative).
|
||||
|
||||
explicit LandingPadInfo(MachineBasicBlock *MBB)
|
||||
: LandingPadBlock(MBB), LandingPadLabel(nullptr) {}
|
||||
: LandingPadBlock(MBB) {}
|
||||
};
|
||||
|
||||
class MachineFunction {
|
||||
@ -239,7 +267,7 @@ class MachineFunction {
|
||||
Recycler<MachineBasicBlock> BasicBlockRecycler;
|
||||
|
||||
// List of machine basic blocks in function
|
||||
typedef ilist<MachineBasicBlock> BasicBlockListType;
|
||||
using BasicBlockListType = ilist<MachineBasicBlock>;
|
||||
BasicBlockListType BasicBlocks;
|
||||
|
||||
/// FunctionNumber - This provides a unique ID for each function emitted in
|
||||
@ -303,9 +331,6 @@ class MachineFunction {
|
||||
|
||||
/// \}
|
||||
|
||||
MachineFunction(const MachineFunction &) = delete;
|
||||
void operator=(const MachineFunction&) = delete;
|
||||
|
||||
/// Clear all the members of this MachineFunction, but the ones used
|
||||
/// to initialize again the MachineFunction.
|
||||
/// More specifically, this deallocates all the dynamically allocated
|
||||
@ -316,8 +341,8 @@ class MachineFunction {
|
||||
/// In particular, the XXXInfo data structure.
|
||||
/// \pre Fn, Target, MMI, and FunctionNumber are properly set.
|
||||
void init();
|
||||
public:
|
||||
|
||||
public:
|
||||
struct VariableDbgInfo {
|
||||
const DILocalVariable *Var;
|
||||
const DIExpression *Expr;
|
||||
@ -328,11 +353,13 @@ class MachineFunction {
|
||||
unsigned Slot, const DILocation *Loc)
|
||||
: Var(Var), Expr(Expr), Slot(Slot), Loc(Loc) {}
|
||||
};
|
||||
typedef SmallVector<VariableDbgInfo, 4> VariableDbgInfoMapTy;
|
||||
using VariableDbgInfoMapTy = SmallVector<VariableDbgInfo, 4>;
|
||||
VariableDbgInfoMapTy VariableDbgInfos;
|
||||
|
||||
MachineFunction(const Function *Fn, const TargetMachine &TM,
|
||||
unsigned FunctionNum, MachineModuleInfo &MMI);
|
||||
MachineFunction(const MachineFunction &) = delete;
|
||||
MachineFunction &operator=(const MachineFunction &) = delete;
|
||||
~MachineFunction();
|
||||
|
||||
/// Reset the instance as if it was just created.
|
||||
@ -350,19 +377,15 @@ class MachineFunction {
|
||||
const DataLayout &getDataLayout() const;
|
||||
|
||||
/// getFunction - Return the LLVM function that this machine code represents
|
||||
///
|
||||
const Function *getFunction() const { return Fn; }
|
||||
|
||||
/// getName - Return the name of the corresponding LLVM function.
|
||||
///
|
||||
StringRef getName() const;
|
||||
|
||||
/// getFunctionNumber - Return a unique ID for the current function.
|
||||
///
|
||||
unsigned getFunctionNumber() const { return FunctionNumber; }
|
||||
|
||||
/// getTarget - Return the target machine this machine code is compiled with
|
||||
///
|
||||
const TargetMachine &getTarget() const { return Target; }
|
||||
|
||||
/// getSubtarget - Return the subtarget for which this machine code is being
|
||||
@ -378,14 +401,12 @@ class MachineFunction {
|
||||
}
|
||||
|
||||
/// getRegInfo - Return information about the registers currently in use.
|
||||
///
|
||||
MachineRegisterInfo &getRegInfo() { return *RegInfo; }
|
||||
const MachineRegisterInfo &getRegInfo() const { return *RegInfo; }
|
||||
|
||||
/// getFrameInfo - Return the frame info object for the current function.
|
||||
/// This object contains information about objects allocated on the stack
|
||||
/// frame of the current function in an abstract way.
|
||||
///
|
||||
MachineFrameInfo &getFrameInfo() { return *FrameInfo; }
|
||||
const MachineFrameInfo &getFrameInfo() const { return *FrameInfo; }
|
||||
|
||||
@ -402,7 +423,6 @@ class MachineFunction {
|
||||
|
||||
/// getConstantPool - Return the constant pool object for the current
|
||||
/// function.
|
||||
///
|
||||
MachineConstantPool *getConstantPool() { return ConstantPool; }
|
||||
const MachineConstantPool *getConstantPool() const { return ConstantPool; }
|
||||
|
||||
@ -413,11 +433,9 @@ class MachineFunction {
|
||||
WinEHFuncInfo *getWinEHFuncInfo() { return WinEHInfo; }
|
||||
|
||||
/// getAlignment - Return the alignment (log2, not bytes) of the function.
|
||||
///
|
||||
unsigned getAlignment() const { return Alignment; }
|
||||
|
||||
/// setAlignment - Set the alignment (log2, not bytes) of the function.
|
||||
///
|
||||
void setAlignment(unsigned A) { Alignment = A; }
|
||||
|
||||
/// ensureAlignment - Make sure the function is at least 1 << A bytes aligned.
|
||||
@ -487,7 +505,6 @@ class MachineFunction {
|
||||
bool shouldSplitStack() const;
|
||||
|
||||
/// getNumBlockIDs - Return the number of MBB ID's allocated.
|
||||
///
|
||||
unsigned getNumBlockIDs() const { return (unsigned)MBBNumbering.size(); }
|
||||
|
||||
/// RenumberBlocks - This discards all of the MachineBasicBlock numbers and
|
||||
@ -499,7 +516,6 @@ class MachineFunction {
|
||||
|
||||
/// print - Print out the MachineFunction in a format suitable for debugging
|
||||
/// to the specified stream.
|
||||
///
|
||||
void print(raw_ostream &OS, const SlotIndexes* = nullptr) const;
|
||||
|
||||
/// viewCFG - This function is meant for use from the debugger. You can just
|
||||
@ -507,7 +523,6 @@ class MachineFunction {
|
||||
/// program, displaying the CFG of the current function with the code for each
|
||||
/// basic block inside. This depends on there being a 'dot' and 'gv' program
|
||||
/// in your path.
|
||||
///
|
||||
void viewCFG() const;
|
||||
|
||||
/// viewCFGOnly - This function is meant for use from the debugger. It works
|
||||
@ -518,7 +533,6 @@ class MachineFunction {
|
||||
void viewCFGOnly() const;
|
||||
|
||||
/// dump - Print the current MachineFunction to cerr, useful for debugger use.
|
||||
///
|
||||
void dump() const;
|
||||
|
||||
/// Run the current MachineFunction through the machine code verifier, useful
|
||||
@ -528,10 +542,10 @@ class MachineFunction {
|
||||
bool AbortOnError = true) const;
|
||||
|
||||
// Provide accessors for the MachineBasicBlock list...
|
||||
typedef BasicBlockListType::iterator iterator;
|
||||
typedef BasicBlockListType::const_iterator const_iterator;
|
||||
typedef BasicBlockListType::const_reverse_iterator const_reverse_iterator;
|
||||
typedef BasicBlockListType::reverse_iterator reverse_iterator;
|
||||
using iterator = BasicBlockListType::iterator;
|
||||
using const_iterator = BasicBlockListType::const_iterator;
|
||||
using const_reverse_iterator = BasicBlockListType::const_reverse_iterator;
|
||||
using reverse_iterator = BasicBlockListType::reverse_iterator;
|
||||
|
||||
/// Support for MachineBasicBlock::getNextNode().
|
||||
static BasicBlockListType MachineFunction::*
|
||||
@ -590,11 +604,9 @@ class MachineFunction {
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Internal functions used to automatically number MachineBasicBlocks
|
||||
//
|
||||
|
||||
/// \brief Adds the MBB to the internal numbering. Returns the unique number
|
||||
/// assigned to the MBB.
|
||||
///
|
||||
unsigned addToMBBNumbering(MachineBasicBlock *MBB) {
|
||||
MBBNumbering.push_back(MBB);
|
||||
return (unsigned)MBBNumbering.size()-1;
|
||||
@ -610,7 +622,6 @@ class MachineFunction {
|
||||
|
||||
/// CreateMachineInstr - Allocate a new MachineInstr. Use this instead
|
||||
/// of `new MachineInstr'.
|
||||
///
|
||||
MachineInstr *CreateMachineInstr(const MCInstrDesc &MCID, const DebugLoc &DL,
|
||||
bool NoImp = false);
|
||||
|
||||
@ -623,16 +634,13 @@ class MachineFunction {
|
||||
MachineInstr *CloneMachineInstr(const MachineInstr *Orig);
|
||||
|
||||
/// DeleteMachineInstr - Delete the given MachineInstr.
|
||||
///
|
||||
void DeleteMachineInstr(MachineInstr *MI);
|
||||
|
||||
/// CreateMachineBasicBlock - Allocate a new MachineBasicBlock. Use this
|
||||
/// instead of `new MachineBasicBlock'.
|
||||
///
|
||||
MachineBasicBlock *CreateMachineBasicBlock(const BasicBlock *bb = nullptr);
|
||||
|
||||
/// DeleteMachineBasicBlock - Delete the given MachineBasicBlock.
|
||||
///
|
||||
void DeleteMachineBasicBlock(MachineBasicBlock *MBB);
|
||||
|
||||
/// getMachineMemOperand - Allocate a new MachineMemOperand.
|
||||
@ -653,7 +661,7 @@ class MachineFunction {
|
||||
MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
|
||||
int64_t Offset, uint64_t Size);
|
||||
|
||||
typedef ArrayRecycler<MachineOperand>::Capacity OperandCapacity;
|
||||
using OperandCapacity = ArrayRecycler<MachineOperand>::Capacity;
|
||||
|
||||
/// Allocate an array of MachineOperands. This is only intended for use by
|
||||
/// internal MachineInstr functions.
|
||||
@ -700,7 +708,6 @@ class MachineFunction {
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Label Manipulation.
|
||||
//
|
||||
|
||||
/// getJTISymbol - Return the MCSymbol for the specified non-empty jump table.
|
||||
/// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
|
||||
@ -858,13 +865,16 @@ template <> struct GraphTraits<MachineFunction*> :
|
||||
static NodeRef getEntryNode(MachineFunction *F) { return &F->front(); }
|
||||
|
||||
// nodes_iterator/begin/end - Allow iteration over all nodes in the graph
|
||||
typedef pointer_iterator<MachineFunction::iterator> nodes_iterator;
|
||||
using nodes_iterator = pointer_iterator<MachineFunction::iterator>;
|
||||
|
||||
static nodes_iterator nodes_begin(MachineFunction *F) {
|
||||
return nodes_iterator(F->begin());
|
||||
}
|
||||
|
||||
static nodes_iterator nodes_end(MachineFunction *F) {
|
||||
return nodes_iterator(F->end());
|
||||
}
|
||||
|
||||
static unsigned size (MachineFunction *F) { return F->size(); }
|
||||
};
|
||||
template <> struct GraphTraits<const MachineFunction*> :
|
||||
@ -872,19 +882,21 @@ template <> struct GraphTraits<const MachineFunction*> :
|
||||
static NodeRef getEntryNode(const MachineFunction *F) { return &F->front(); }
|
||||
|
||||
// nodes_iterator/begin/end - Allow iteration over all nodes in the graph
|
||||
typedef pointer_iterator<MachineFunction::const_iterator> nodes_iterator;
|
||||
using nodes_iterator = pointer_iterator<MachineFunction::const_iterator>;
|
||||
|
||||
static nodes_iterator nodes_begin(const MachineFunction *F) {
|
||||
return nodes_iterator(F->begin());
|
||||
}
|
||||
|
||||
static nodes_iterator nodes_end (const MachineFunction *F) {
|
||||
return nodes_iterator(F->end());
|
||||
}
|
||||
|
||||
static unsigned size (const MachineFunction *F) {
|
||||
return F->size();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// Provide specializations of GraphTraits to be able to treat a function as a
|
||||
// graph of basic blocks... and to walk it in inverse order. Inverse order for
|
||||
// a function is considered to be when traversing the predecessor edges of a BB
|
||||
@ -903,6 +915,6 @@ template <> struct GraphTraits<Inverse<const MachineFunction*> > :
|
||||
}
|
||||
};
|
||||
|
||||
} // End llvm namespace
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_CODEGEN_MACHINEFUNCTION_H
|
||||
|
@ -1,4 +1,4 @@
|
||||
//===- MachineFunctionInitializer.h - machine function initializer ---------===//
|
||||
//=- MachineFunctionInitializer.h - machine function initializer --*- C++ -*-=//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -25,7 +25,7 @@ class MachineFunctionInitializer {
|
||||
virtual void anchor();
|
||||
|
||||
public:
|
||||
virtual ~MachineFunctionInitializer() {}
|
||||
virtual ~MachineFunctionInitializer() = default;
|
||||
|
||||
/// Initialize the machine function.
|
||||
///
|
||||
@ -35,4 +35,4 @@ class MachineFunctionInitializer {
|
||||
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_CODEGEN_MACHINEFUNCTIONINITIALIZER_H
|
||||
|
@ -1,4 +1,4 @@
|
||||
//===-- llvm/CodeGen/MachineInstr.h - MachineInstr class --------*- C++ -*-===//
|
||||
//===- llvm/CodeGen/MachineInstr.h - MachineInstr class ---------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -17,7 +17,6 @@
|
||||
#define LLVM_CODEGEN_MACHINEINSTR_H
|
||||
|
||||
#include "llvm/ADT/DenseMapInfo.h"
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
#include "llvm/ADT/ilist.h"
|
||||
#include "llvm/ADT/ilist_node.h"
|
||||
#include "llvm/ADT/iterator_range.h"
|
||||
@ -28,19 +27,27 @@
|
||||
#include "llvm/MC/MCInstrDesc.h"
|
||||
#include "llvm/Support/ArrayRecycler.h"
|
||||
#include "llvm/Target/TargetOpcodes.h"
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include <utility>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
class StringRef;
|
||||
template <typename T> class ArrayRef;
|
||||
template <typename T> class SmallVectorImpl;
|
||||
class DILocalVariable;
|
||||
class DIExpression;
|
||||
class DILocalVariable;
|
||||
class MachineBasicBlock;
|
||||
class MachineFunction;
|
||||
class MachineMemOperand;
|
||||
class MachineRegisterInfo;
|
||||
class ModuleSlotTracker;
|
||||
class raw_ostream;
|
||||
template <typename T> class SmallVectorImpl;
|
||||
class StringRef;
|
||||
class TargetInstrInfo;
|
||||
class TargetRegisterClass;
|
||||
class TargetRegisterInfo;
|
||||
class MachineFunction;
|
||||
class MachineMemOperand;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// Representation of each machine instruction.
|
||||
@ -53,7 +60,7 @@ class MachineInstr
|
||||
: public ilist_node_with_parent<MachineInstr, MachineBasicBlock,
|
||||
ilist_sentinel_tracking<true>> {
|
||||
public:
|
||||
typedef MachineMemOperand **mmo_iterator;
|
||||
using mmo_iterator = MachineMemOperand **;
|
||||
|
||||
/// Flags to specify different kinds of comments to output in
|
||||
/// assembly code. These flags carry semantic information not
|
||||
@ -72,43 +79,39 @@ class MachineInstr
|
||||
BundledPred = 1 << 2, // Instruction has bundled predecessors.
|
||||
BundledSucc = 1 << 3 // Instruction has bundled successors.
|
||||
};
|
||||
|
||||
private:
|
||||
const MCInstrDesc *MCID; // Instruction descriptor.
|
||||
MachineBasicBlock *Parent; // Pointer to the owning basic block.
|
||||
MachineBasicBlock *Parent = nullptr; // Pointer to the owning basic block.
|
||||
|
||||
// Operands are allocated by an ArrayRecycler.
|
||||
MachineOperand *Operands; // Pointer to the first operand.
|
||||
unsigned NumOperands; // Number of operands on instruction.
|
||||
typedef ArrayRecycler<MachineOperand>::Capacity OperandCapacity;
|
||||
MachineOperand *Operands = nullptr; // Pointer to the first operand.
|
||||
unsigned NumOperands = 0; // Number of operands on instruction.
|
||||
using OperandCapacity = ArrayRecycler<MachineOperand>::Capacity;
|
||||
OperandCapacity CapOperands; // Capacity of the Operands array.
|
||||
|
||||
uint8_t Flags; // Various bits of additional
|
||||
uint8_t Flags = 0; // Various bits of additional
|
||||
// information about machine
|
||||
// instruction.
|
||||
|
||||
uint8_t AsmPrinterFlags; // Various bits of information used by
|
||||
uint8_t AsmPrinterFlags = 0; // Various bits of information used by
|
||||
// the AsmPrinter to emit helpful
|
||||
// comments. This is *not* semantic
|
||||
// information. Do not use this for
|
||||
// anything other than to convey comment
|
||||
// information to AsmPrinter.
|
||||
|
||||
uint8_t NumMemRefs; // Information on memory references.
|
||||
uint8_t NumMemRefs = 0; // Information on memory references.
|
||||
// Note that MemRefs == nullptr, means 'don't know', not 'no memory access'.
|
||||
// Calling code must treat missing information conservatively. If the number
|
||||
// of memory operands required to be precise exceeds the maximum value of
|
||||
// NumMemRefs - currently 256 - we remove the operands entirely. Note also
|
||||
// that this is a non-owning reference to a shared copy on write buffer owned
|
||||
// by the MachineFunction and created via MF.allocateMemRefsArray.
|
||||
mmo_iterator MemRefs;
|
||||
mmo_iterator MemRefs = nullptr;
|
||||
|
||||
DebugLoc debugLoc; // Source line information.
|
||||
|
||||
MachineInstr(const MachineInstr&) = delete;
|
||||
void operator=(const MachineInstr&) = delete;
|
||||
// Use MachineFunction::DeleteMachineInstr() instead.
|
||||
~MachineInstr() = delete;
|
||||
|
||||
// Intrusive list support
|
||||
friend struct ilist_traits<MachineInstr>;
|
||||
friend struct ilist_callback_traits<MachineBasicBlock>;
|
||||
@ -128,6 +131,11 @@ class MachineInstr
|
||||
friend class MachineFunction;
|
||||
|
||||
public:
|
||||
MachineInstr(const MachineInstr &) = delete;
|
||||
MachineInstr &operator=(const MachineInstr &) = delete;
|
||||
// Use MachineFunction::DeleteMachineInstr() instead.
|
||||
~MachineInstr() = delete;
|
||||
|
||||
const MachineBasicBlock* getParent() const { return Parent; }
|
||||
MachineBasicBlock* getParent() { return Parent; }
|
||||
|
||||
@ -178,7 +186,6 @@ class MachineInstr
|
||||
Flags &= ~((uint8_t)Flag);
|
||||
}
|
||||
|
||||
|
||||
/// Return true if MI is in a bundle (but not the first MI in a bundle).
|
||||
///
|
||||
/// A bundle looks like this before it's finalized:
|
||||
@ -263,7 +270,6 @@ class MachineInstr
|
||||
/// earlier.
|
||||
///
|
||||
/// If this method returns, the caller should try to recover from the error.
|
||||
///
|
||||
void emitError(StringRef Msg) const;
|
||||
|
||||
/// Returns the target instruction descriptor of this MachineInstr.
|
||||
@ -273,7 +279,6 @@ class MachineInstr
|
||||
unsigned getOpcode() const { return MCID->Opcode; }
|
||||
|
||||
/// Access to explicit operands of the instruction.
|
||||
///
|
||||
unsigned getNumOperands() const { return NumOperands; }
|
||||
|
||||
const MachineOperand& getOperand(unsigned i) const {
|
||||
@ -289,8 +294,8 @@ class MachineInstr
|
||||
unsigned getNumExplicitOperands() const;
|
||||
|
||||
/// iterator/begin/end - Iterate over all operands of a machine instruction.
|
||||
typedef MachineOperand *mop_iterator;
|
||||
typedef const MachineOperand *const_mop_iterator;
|
||||
using mop_iterator = MachineOperand *;
|
||||
using const_mop_iterator = const MachineOperand *;
|
||||
|
||||
mop_iterator operands_begin() { return Operands; }
|
||||
mop_iterator operands_end() { return Operands + NumOperands; }
|
||||
@ -713,7 +718,6 @@ class MachineInstr
|
||||
return hasProperty(MCID::ExtraDefRegAllocReq, Type);
|
||||
}
|
||||
|
||||
|
||||
enum MICheckType {
|
||||
CheckDefs, // Check all operands for equality
|
||||
CheckKillDead, // Check all operands including kill / dead markers
|
||||
@ -767,6 +771,7 @@ class MachineInstr
|
||||
|
||||
/// Returns true if the MachineInstr represents a label.
|
||||
bool isLabel() const { return isEHLabel() || isGCLabel(); }
|
||||
|
||||
bool isCFIInstruction() const {
|
||||
return getOpcode() == TargetOpcode::CFI_INSTRUCTION;
|
||||
}
|
||||
@ -775,6 +780,7 @@ class MachineInstr
|
||||
bool isPosition() const { return isLabel() || isCFIInstruction(); }
|
||||
|
||||
bool isDebugValue() const { return getOpcode() == TargetOpcode::DBG_VALUE; }
|
||||
|
||||
/// A DBG_VALUE is indirect iff the first operand is a register and
|
||||
/// the second operand is an immediate.
|
||||
bool isIndirectDebugValue() const {
|
||||
@ -787,29 +793,38 @@ class MachineInstr
|
||||
bool isKill() const { return getOpcode() == TargetOpcode::KILL; }
|
||||
bool isImplicitDef() const { return getOpcode()==TargetOpcode::IMPLICIT_DEF; }
|
||||
bool isInlineAsm() const { return getOpcode() == TargetOpcode::INLINEASM; }
|
||||
|
||||
bool isMSInlineAsm() const {
|
||||
return getOpcode() == TargetOpcode::INLINEASM && getInlineAsmDialect();
|
||||
}
|
||||
|
||||
bool isStackAligningInlineAsm() const;
|
||||
InlineAsm::AsmDialect getInlineAsmDialect() const;
|
||||
|
||||
bool isInsertSubreg() const {
|
||||
return getOpcode() == TargetOpcode::INSERT_SUBREG;
|
||||
}
|
||||
|
||||
bool isSubregToReg() const {
|
||||
return getOpcode() == TargetOpcode::SUBREG_TO_REG;
|
||||
}
|
||||
|
||||
bool isRegSequence() const {
|
||||
return getOpcode() == TargetOpcode::REG_SEQUENCE;
|
||||
}
|
||||
|
||||
bool isBundle() const {
|
||||
return getOpcode() == TargetOpcode::BUNDLE;
|
||||
}
|
||||
|
||||
bool isCopy() const {
|
||||
return getOpcode() == TargetOpcode::COPY;
|
||||
}
|
||||
|
||||
bool isFullCopy() const {
|
||||
return isCopy() && !getOperand(0).getSubReg() && !getOperand(1).getSubReg();
|
||||
}
|
||||
|
||||
bool isExtractSubreg() const {
|
||||
return getOpcode() == TargetOpcode::EXTRACT_SUBREG;
|
||||
}
|
||||
@ -978,7 +993,6 @@ class MachineInstr
|
||||
///
|
||||
/// The flag operand is an immediate that can be decoded with methods like
|
||||
/// InlineAsm::hasRegClassConstraint().
|
||||
///
|
||||
int findInlineAsmFlagIdx(unsigned OpIdx, unsigned *GroupNo = nullptr) const;
|
||||
|
||||
/// Compute the static register class constraint for operand OpIdx.
|
||||
@ -987,7 +1001,6 @@ class MachineInstr
|
||||
///
|
||||
/// Returns NULL if the static register class constraint cannot be
|
||||
/// determined.
|
||||
///
|
||||
const TargetRegisterClass*
|
||||
getRegClassConstraint(unsigned OpIdx,
|
||||
const TargetInstrInfo *TII,
|
||||
@ -1328,6 +1341,6 @@ inline raw_ostream& operator<<(raw_ostream &OS, const MachineInstr &MI) {
|
||||
return OS;
|
||||
}
|
||||
|
||||
} // End llvm namespace
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_CODEGEN_MACHINEINSTR_H
|
||||
|
@ -15,34 +15,37 @@
|
||||
#define LLVM_CODEGEN_MACHINEINSTRBUNDLEITERATOR_H
|
||||
|
||||
#include "llvm/ADT/ilist.h"
|
||||
#include "llvm/ADT/simple_ilist.h"
|
||||
#include <cassert>
|
||||
#include <iterator>
|
||||
#include <type_traits>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
template <class T, bool IsReverse> struct MachineInstrBundleIteratorTraits;
|
||||
template <class T> struct MachineInstrBundleIteratorTraits<T, false> {
|
||||
typedef simple_ilist<T, ilist_sentinel_tracking<true>> list_type;
|
||||
typedef typename list_type::iterator instr_iterator;
|
||||
typedef typename list_type::iterator nonconst_instr_iterator;
|
||||
typedef typename list_type::const_iterator const_instr_iterator;
|
||||
using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>;
|
||||
using instr_iterator = typename list_type::iterator;
|
||||
using nonconst_instr_iterator = typename list_type::iterator;
|
||||
using const_instr_iterator = typename list_type::const_iterator;
|
||||
};
|
||||
template <class T> struct MachineInstrBundleIteratorTraits<T, true> {
|
||||
typedef simple_ilist<T, ilist_sentinel_tracking<true>> list_type;
|
||||
typedef typename list_type::reverse_iterator instr_iterator;
|
||||
typedef typename list_type::reverse_iterator nonconst_instr_iterator;
|
||||
typedef typename list_type::const_reverse_iterator const_instr_iterator;
|
||||
using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>;
|
||||
using instr_iterator = typename list_type::reverse_iterator;
|
||||
using nonconst_instr_iterator = typename list_type::reverse_iterator;
|
||||
using const_instr_iterator = typename list_type::const_reverse_iterator;
|
||||
};
|
||||
template <class T> struct MachineInstrBundleIteratorTraits<const T, false> {
|
||||
typedef simple_ilist<T, ilist_sentinel_tracking<true>> list_type;
|
||||
typedef typename list_type::const_iterator instr_iterator;
|
||||
typedef typename list_type::iterator nonconst_instr_iterator;
|
||||
typedef typename list_type::const_iterator const_instr_iterator;
|
||||
using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>;
|
||||
using instr_iterator = typename list_type::const_iterator;
|
||||
using nonconst_instr_iterator = typename list_type::iterator;
|
||||
using const_instr_iterator = typename list_type::const_iterator;
|
||||
};
|
||||
template <class T> struct MachineInstrBundleIteratorTraits<const T, true> {
|
||||
typedef simple_ilist<T, ilist_sentinel_tracking<true>> list_type;
|
||||
typedef typename list_type::const_reverse_iterator instr_iterator;
|
||||
typedef typename list_type::reverse_iterator nonconst_instr_iterator;
|
||||
typedef typename list_type::const_reverse_iterator const_instr_iterator;
|
||||
using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>;
|
||||
using instr_iterator = typename list_type::const_reverse_iterator;
|
||||
using nonconst_instr_iterator = typename list_type::reverse_iterator;
|
||||
using const_instr_iterator = typename list_type::const_reverse_iterator;
|
||||
};
|
||||
|
||||
template <bool IsReverse> struct MachineInstrBundleIteratorHelper;
|
||||
@ -104,27 +107,27 @@ template <> struct MachineInstrBundleIteratorHelper<true> {
|
||||
/// inside bundles (i.e. walk top level MIs only).
|
||||
template <typename Ty, bool IsReverse = false>
|
||||
class MachineInstrBundleIterator : MachineInstrBundleIteratorHelper<IsReverse> {
|
||||
typedef MachineInstrBundleIteratorTraits<Ty, IsReverse> Traits;
|
||||
typedef typename Traits::instr_iterator instr_iterator;
|
||||
using Traits = MachineInstrBundleIteratorTraits<Ty, IsReverse>;
|
||||
using instr_iterator = typename Traits::instr_iterator;
|
||||
|
||||
instr_iterator MII;
|
||||
|
||||
public:
|
||||
typedef typename instr_iterator::value_type value_type;
|
||||
typedef typename instr_iterator::difference_type difference_type;
|
||||
typedef typename instr_iterator::pointer pointer;
|
||||
typedef typename instr_iterator::reference reference;
|
||||
typedef std::bidirectional_iterator_tag iterator_category;
|
||||
|
||||
typedef typename instr_iterator::const_pointer const_pointer;
|
||||
typedef typename instr_iterator::const_reference const_reference;
|
||||
using value_type = typename instr_iterator::value_type;
|
||||
using difference_type = typename instr_iterator::difference_type;
|
||||
using pointer = typename instr_iterator::pointer;
|
||||
using reference = typename instr_iterator::reference;
|
||||
using const_pointer = typename instr_iterator::const_pointer;
|
||||
using const_reference = typename instr_iterator::const_reference;
|
||||
using iterator_category = std::bidirectional_iterator_tag;
|
||||
|
||||
private:
|
||||
typedef typename Traits::nonconst_instr_iterator nonconst_instr_iterator;
|
||||
typedef typename Traits::const_instr_iterator const_instr_iterator;
|
||||
typedef MachineInstrBundleIterator<
|
||||
typename nonconst_instr_iterator::value_type, IsReverse>
|
||||
nonconst_iterator;
|
||||
typedef MachineInstrBundleIterator<Ty, !IsReverse> reverse_iterator;
|
||||
using nonconst_instr_iterator = typename Traits::nonconst_instr_iterator;
|
||||
using const_instr_iterator = typename Traits::const_instr_iterator;
|
||||
using nonconst_iterator =
|
||||
MachineInstrBundleIterator<typename nonconst_instr_iterator::value_type,
|
||||
IsReverse>;
|
||||
using reverse_iterator = MachineInstrBundleIterator<Ty, !IsReverse>;
|
||||
|
||||
public:
|
||||
MachineInstrBundleIterator(instr_iterator MI) : MII(MI) {
|
||||
@ -138,12 +141,14 @@ class MachineInstrBundleIterator : MachineInstrBundleIteratorHelper<IsReverse> {
|
||||
"MachineInstrBundleIterator with a "
|
||||
"bundled MI");
|
||||
}
|
||||
|
||||
MachineInstrBundleIterator(pointer MI) : MII(MI) {
|
||||
// FIXME: This conversion should be explicit.
|
||||
assert((!MI || !MI->isBundledWithPred()) && "It's not legal to initialize "
|
||||
"MachineInstrBundleIterator "
|
||||
"with a bundled MI");
|
||||
}
|
||||
|
||||
// Template allows conversion from const to nonconst.
|
||||
template <class OtherTy>
|
||||
MachineInstrBundleIterator(
|
||||
@ -151,6 +156,7 @@ class MachineInstrBundleIterator : MachineInstrBundleIteratorHelper<IsReverse> {
|
||||
typename std::enable_if<std::is_convertible<OtherTy *, Ty *>::value,
|
||||
void *>::type = nullptr)
|
||||
: MII(I.getInstrIterator()) {}
|
||||
|
||||
MachineInstrBundleIterator() : MII(nullptr) {}
|
||||
|
||||
/// Explicit conversion between forward/reverse iterators.
|
||||
@ -280,4 +286,4 @@ class MachineInstrBundleIterator : MachineInstrBundleIteratorHelper<IsReverse> {
|
||||
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_CODEGEN_MACHINEINSTRBUNDLEITERATOR_H
|
||||
|
@ -33,6 +33,8 @@
|
||||
#include "llvm/Analysis/LoopInfo.h"
|
||||
#include "llvm/CodeGen/MachineBasicBlock.h"
|
||||
#include "llvm/CodeGen/MachineFunctionPass.h"
|
||||
#include "llvm/IR/DebugLoc.h"
|
||||
#include "llvm/Pass.h"
|
||||
|
||||
namespace llvm {
|
||||
|
||||
@ -71,6 +73,7 @@ class MachineLoop : public LoopBase<MachineBasicBlock, MachineLoop> {
|
||||
|
||||
private:
|
||||
friend class LoopInfoBase<MachineBasicBlock, MachineLoop>;
|
||||
|
||||
explicit MachineLoop(MachineBasicBlock *MBB)
|
||||
: LoopBase<MachineBasicBlock, MachineLoop>(MBB) {}
|
||||
};
|
||||
@ -79,11 +82,9 @@ class MachineLoop : public LoopBase<MachineBasicBlock, MachineLoop> {
|
||||
extern template class LoopInfoBase<MachineBasicBlock, MachineLoop>;
|
||||
|
||||
class MachineLoopInfo : public MachineFunctionPass {
|
||||
LoopInfoBase<MachineBasicBlock, MachineLoop> LI;
|
||||
friend class LoopBase<MachineBasicBlock, MachineLoop>;
|
||||
|
||||
void operator=(const MachineLoopInfo &) = delete;
|
||||
MachineLoopInfo(const MachineLoopInfo &) = delete;
|
||||
LoopInfoBase<MachineBasicBlock, MachineLoop> LI;
|
||||
|
||||
public:
|
||||
static char ID; // Pass identification, replacement for typeid
|
||||
@ -91,6 +92,8 @@ class MachineLoopInfo : public MachineFunctionPass {
|
||||
MachineLoopInfo() : MachineFunctionPass(ID) {
|
||||
initializeMachineLoopInfoPass(*PassRegistry::getPassRegistry());
|
||||
}
|
||||
MachineLoopInfo(const MachineLoopInfo &) = delete;
|
||||
MachineLoopInfo &operator=(const MachineLoopInfo &) = delete;
|
||||
|
||||
LoopInfoBase<MachineBasicBlock, MachineLoop>& getBase() { return LI; }
|
||||
|
||||
@ -103,7 +106,7 @@ class MachineLoopInfo : public MachineFunctionPass {
|
||||
bool SpeculativePreheader = false) const;
|
||||
|
||||
/// The iterator interface to the top-level loops in the current function.
|
||||
typedef LoopInfoBase<MachineBasicBlock, MachineLoop>::iterator iterator;
|
||||
using iterator = LoopInfoBase<MachineBasicBlock, MachineLoop>::iterator;
|
||||
inline iterator begin() const { return LI.begin(); }
|
||||
inline iterator end() const { return LI.end(); }
|
||||
bool empty() const { return LI.empty(); }
|
||||
@ -166,11 +169,10 @@ class MachineLoopInfo : public MachineFunctionPass {
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// Allow clients to walk the list of nested loops...
|
||||
template <> struct GraphTraits<const MachineLoop*> {
|
||||
typedef const MachineLoop *NodeRef;
|
||||
typedef MachineLoopInfo::iterator ChildIteratorType;
|
||||
using NodeRef = const MachineLoop *;
|
||||
using ChildIteratorType = MachineLoopInfo::iterator;
|
||||
|
||||
static NodeRef getEntryNode(const MachineLoop *L) { return L; }
|
||||
static ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
|
||||
@ -178,14 +180,14 @@ template <> struct GraphTraits<const MachineLoop*> {
|
||||
};
|
||||
|
||||
template <> struct GraphTraits<MachineLoop*> {
|
||||
typedef MachineLoop *NodeRef;
|
||||
typedef MachineLoopInfo::iterator ChildIteratorType;
|
||||
using NodeRef = MachineLoop *;
|
||||
using ChildIteratorType = MachineLoopInfo::iterator;
|
||||
|
||||
static NodeRef getEntryNode(MachineLoop *L) { return L; }
|
||||
static ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
|
||||
static ChildIteratorType child_end(NodeRef N) { return N->end(); }
|
||||
};
|
||||
|
||||
} // End llvm namespace
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_CODEGEN_MACHINELOOPINFO_H
|
||||
|
@ -31,35 +31,26 @@
|
||||
#ifndef LLVM_CODEGEN_MACHINEMODULEINFO_H
|
||||
#define LLVM_CODEGEN_MACHINEMODULEINFO_H
|
||||
|
||||
#include "llvm/ADT/ArrayRef.h"
|
||||
#include "llvm/ADT/DenseMap.h"
|
||||
#include "llvm/ADT/PointerIntPair.h"
|
||||
#include "llvm/ADT/SmallPtrSet.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include "llvm/IR/DebugLoc.h"
|
||||
#include "llvm/IR/ValueHandle.h"
|
||||
#include "llvm/MC/MCContext.h"
|
||||
#include "llvm/MC/MCSymbol.h"
|
||||
#include "llvm/MC/MachineLocation.h"
|
||||
#include "llvm/Pass.h"
|
||||
#include "llvm/Support/DataTypes.h"
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Forward declarations.
|
||||
class BlockAddress;
|
||||
class BasicBlock;
|
||||
class CallInst;
|
||||
class Constant;
|
||||
class GlobalVariable;
|
||||
class LandingPadInst;
|
||||
class MDNode;
|
||||
class MMIAddrLabelMap;
|
||||
class MachineBasicBlock;
|
||||
class Function;
|
||||
class MachineFunction;
|
||||
class MachineFunctionInitializer;
|
||||
class MMIAddrLabelMap;
|
||||
class Module;
|
||||
class PointerType;
|
||||
class StructType;
|
||||
class TargetMachine;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// This class can be derived from and used by targets to hold private
|
||||
@ -69,11 +60,12 @@ class StructType;
|
||||
///
|
||||
class MachineModuleInfoImpl {
|
||||
public:
|
||||
typedef PointerIntPair<MCSymbol*, 1, bool> StubValueTy;
|
||||
virtual ~MachineModuleInfoImpl();
|
||||
typedef std::vector<std::pair<MCSymbol*, StubValueTy> > SymbolListTy;
|
||||
protected:
|
||||
using StubValueTy = PointerIntPair<MCSymbol *, 1, bool>;
|
||||
using SymbolListTy = std::vector<std::pair<MCSymbol *, StubValueTy>>;
|
||||
|
||||
virtual ~MachineModuleInfoImpl();
|
||||
|
||||
protected:
|
||||
/// Return the entries from a DenseMap in a deterministic sorted orer.
|
||||
/// Clears the map.
|
||||
static SymbolListTy getSortedStubs(DenseMap<MCSymbol*, StubValueTy>&);
|
||||
@ -252,6 +244,6 @@ class MachineModuleInfo : public ImmutablePass {
|
||||
/// which will link in MSVCRT's floating-point support.
|
||||
void computeUsesVAFloatArgument(const CallInst &I, MachineModuleInfo &MMI);
|
||||
|
||||
} // End llvm namespace
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_CODEGEN_MACHINEMODULEINFO_H
|
||||
|
@ -133,6 +133,10 @@ namespace llvm {
|
||||
// instruction and update the MachineFunctionInfo with that information.
|
||||
extern char &ShrinkWrapID;
|
||||
|
||||
/// LiveRangeShrink pass. Move instruction close to its definition to shrink
|
||||
/// the definition's live range.
|
||||
extern char &LiveRangeShrinkID;
|
||||
|
||||
/// Greedy register allocator.
|
||||
extern char &RAGreedyID;
|
||||
|
||||
|
@ -22,7 +22,7 @@ namespace llvm {
|
||||
|
||||
class PassConfigImpl;
|
||||
class ScheduleDAGInstrs;
|
||||
class TargetMachine;
|
||||
class LLVMTargetMachine;
|
||||
struct MachineSchedContext;
|
||||
|
||||
// The old pass manager infrastructure is hidden in a legacy namespace now.
|
||||
@ -103,7 +103,7 @@ class TargetPassConfig : public ImmutablePass {
|
||||
bool AddingMachinePasses;
|
||||
|
||||
protected:
|
||||
TargetMachine *TM;
|
||||
LLVMTargetMachine *TM;
|
||||
PassConfigImpl *Impl; // Internal data structures
|
||||
bool Initialized; // Flagged after all passes are configured.
|
||||
|
||||
@ -120,7 +120,7 @@ class TargetPassConfig : public ImmutablePass {
|
||||
bool RequireCodeGenSCCOrder;
|
||||
|
||||
public:
|
||||
TargetPassConfig(TargetMachine *tm, PassManagerBase &pm);
|
||||
TargetPassConfig(LLVMTargetMachine &TM, PassManagerBase &pm);
|
||||
// Dummy constructor.
|
||||
TargetPassConfig();
|
||||
|
||||
|
@ -6,6 +6,10 @@
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Defines constants and basic types describing CodeView debug information.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef LLVM_DEBUGINFO_CODEVIEW_CODEVIEW_H
|
||||
#define LLVM_DEBUGINFO_CODEVIEW_CODEVIEW_H
|
||||
@ -22,28 +26,28 @@ namespace codeview {
|
||||
/// documentation and headers talk about this as the "leaf" type.
|
||||
enum class TypeRecordKind : uint16_t {
|
||||
#define TYPE_RECORD(lf_ename, value, name) name = value,
|
||||
#include "TypeRecords.def"
|
||||
#include "CodeViewTypes.def"
|
||||
};
|
||||
|
||||
/// Duplicate copy of the above enum, but using the official CV names. Useful
|
||||
/// for reference purposes and when dealing with unknown record types.
|
||||
enum TypeLeafKind : uint16_t {
|
||||
#define CV_TYPE(name, val) name = val,
|
||||
#include "TypeRecords.def"
|
||||
#include "CodeViewTypes.def"
|
||||
};
|
||||
|
||||
/// Distinguishes individual records in the Symbols subsection of a .debug$S
|
||||
/// section. Equivalent to SYM_ENUM_e in cvinfo.h.
|
||||
enum class SymbolRecordKind : uint16_t {
|
||||
#define SYMBOL_RECORD(lf_ename, value, name) name = value,
|
||||
#include "CVSymbolTypes.def"
|
||||
#include "CodeViewSymbols.def"
|
||||
};
|
||||
|
||||
/// Duplicate copy of the above enum, but using the official CV names. Useful
|
||||
/// for reference purposes and when dealing with unknown record types.
|
||||
enum SymbolKind : uint16_t {
|
||||
#define CV_SYMBOL(name, val) name = val,
|
||||
#include "CVSymbolTypes.def"
|
||||
#include "CodeViewSymbols.def"
|
||||
};
|
||||
|
||||
#define CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(Class) \
|
||||
|
@ -34,6 +34,17 @@ class SymbolDeserializer : public SymbolVisitorCallbacks {
|
||||
};
|
||||
|
||||
public:
|
||||
template <typename T> static Error deserializeAs(CVSymbol Symbol, T &Record) {
|
||||
SymbolDeserializer S(nullptr);
|
||||
if (auto EC = S.visitSymbolBegin(Symbol))
|
||||
return EC;
|
||||
if (auto EC = S.visitKnownRecord(Symbol, Record))
|
||||
return EC;
|
||||
if (auto EC = S.visitSymbolEnd(Symbol))
|
||||
return EC;
|
||||
return Error::success();
|
||||
}
|
||||
|
||||
explicit SymbolDeserializer(SymbolVisitorDelegate *Delegate)
|
||||
: Delegate(Delegate) {}
|
||||
|
||||
@ -54,7 +65,7 @@ class SymbolDeserializer : public SymbolVisitorCallbacks {
|
||||
return visitKnownRecordImpl(CVR, Record); \
|
||||
}
|
||||
#define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
|
||||
#include "CVSymbolTypes.def"
|
||||
#include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
|
||||
|
||||
private:
|
||||
template <typename T> Error visitKnownRecordImpl(CVSymbol &CVR, T &Record) {
|
||||
|
@ -35,8 +35,6 @@ class SymbolRecord {
|
||||
|
||||
public:
|
||||
SymbolRecordKind getKind() const { return Kind; }
|
||||
|
||||
private:
|
||||
SymbolRecordKind Kind;
|
||||
};
|
||||
|
||||
|
@ -29,7 +29,7 @@ class SymbolRecordMapping : public SymbolVisitorCallbacks {
|
||||
#define SYMBOL_RECORD(EnumName, EnumVal, Name) \
|
||||
Error visitKnownRecord(CVSymbol &CVR, Name &Record) override;
|
||||
#define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
|
||||
#include "CVSymbolTypes.def"
|
||||
#include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
|
||||
|
||||
private:
|
||||
Optional<SymbolKind> Kind;
|
||||
|
@ -45,6 +45,17 @@ class SymbolSerializer : public SymbolVisitorCallbacks {
|
||||
}
|
||||
|
||||
public:
|
||||
template <typename SymType>
|
||||
static CVSymbol writeOneSymbol(SymType &Sym, BumpPtrAllocator &Storage) {
|
||||
CVSymbol Result;
|
||||
Result.Type = static_cast<SymbolKind>(Sym.Kind);
|
||||
SymbolSerializer Serializer(Storage);
|
||||
consumeError(Serializer.visitSymbolBegin(Result));
|
||||
consumeError(Serializer.visitKnownRecord(Result, Sym));
|
||||
consumeError(Serializer.visitSymbolEnd(Result));
|
||||
return Result;
|
||||
}
|
||||
|
||||
explicit SymbolSerializer(BumpPtrAllocator &Storage);
|
||||
|
||||
virtual Error visitSymbolBegin(CVSymbol &Record) override;
|
||||
@ -55,7 +66,7 @@ class SymbolSerializer : public SymbolVisitorCallbacks {
|
||||
return visitKnownRecordImpl(CVR, Record); \
|
||||
}
|
||||
#define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
|
||||
#include "CVSymbolTypes.def"
|
||||
#include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
|
||||
|
||||
private:
|
||||
template <typename RecordKind>
|
||||
|
@ -59,7 +59,7 @@ class SymbolVisitorCallbackPipeline : public SymbolVisitorCallbacks {
|
||||
return Error::success(); \
|
||||
}
|
||||
#define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
|
||||
#include "llvm/DebugInfo/CodeView/CVSymbolTypes.def"
|
||||
#include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
|
||||
|
||||
private:
|
||||
std::vector<SymbolVisitorCallbacks *> Pipeline;
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user