6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-22 10:24:26 +00:00
Code Issues Projects Releases Wiki Activity

Add support to the hashing infrastructure for automatically hashing both

Browse Source 
integral and enumeration types. This is accomplished with a bit of
template type trait magic. Thanks to Richard Smith for the core idea
here to detect viable types by detecting the set of types which can be
default constructed in a template parameter.

This is used (in conjunction with a system for detecting nullptr_t
should it exist) to provide an is_integral_or_enum type trait that
doesn't need a whitelist or direct compiler support.

With this, the hashing is extended to the more general facility. This
will be used in a subsequent commit to hashing more things, but I wanted
to make sure the type trait magic went through the build bots separately
in case other compilers don't like this formulation.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@152217 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chandler Carruth
2012-03-07 09:32:32 +00:00
parent 5b2749abf5
commit d4d8b2a7f6
3 changed files with 48 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
include/llvm/Support/type_traits.h
View File

@ -121,12 +121,42 @@ template <> struct is_integral_impl<unsigned long long> : true_type {};
template <typename T>
struct is_integral : is_integral_impl<T> {};
/// \brief Metafunction that determines whether the given type is either an
/// integral type or an enumeration type.
///
/// Note that this accepts potentially more integral types than we whitelist
/// above for is_integral, it should accept essentially anything the compiler
/// believes is an integral type.
template <typename T> class is_integral_or_enum {
// Form a return type that can only be instantiated with an integral or enum
// types (or with nullptr_t in C++11).
template <typename U, U u = U()> struct check1_return_type { char c[2]; };
template <typename U> static check1_return_type<U> checker1(U*);
static char checker1(...);
// Form a return type that can only be instantiated with nullptr_t in C++11
// mode. It's harmless in C++98 mode, but this allows us to filter nullptr_t
// when building in C++11 mode without having to detect that mode for each
// different compiler.
struct nonce {};
template <typename U, nonce* u = U()>
struct check2_return_type { char c[2]; };
template <typename U> static check2_return_type<U> checker2(U*);
static char checker2(...);
public:
enum {
value = (sizeof(char) != sizeof(checker1((T*)0)) &&
sizeof(char) == sizeof(checker2((T*)0)))
};
};
/// \brief Metafunction that determines whether the given type is a pointer
/// type.
template <typename T> struct is_pointer : false_type {};
template <typename T> struct is_pointer<T*> : true_type {};
// enable_if_c - Enable/disable a template based on a metafunction
template<bool Cond, typename T = void>
struct enable_if_c {