Fix or suppress GCC warnings during build.

[EricWF]

Summary

Currently a number of GCC warnings are emitted when building libc++. This patch fixes or ignores all of them. The primary changes are:

• Work around strict aliasing issues in typeinfo::hash_code() by using attribute((may_alias)). However I think a non-aliasing hash_code() implementation is possible. Further investigation needed.
• Add _LIBCPP_UNREACHABLE() to switch in strstream.cpp to avoid -Wpotentially-uninitialized.
• Fix -Wunused-value warning in __all by adding a void cast.
• Ignore -Wattributes for now. There are a number of real attribute issues when using GCC but enabling the warning is too noisy.
• Ignore -Wliteral-suffix since it warns about the use of reserved identifiers. Note Only GCC 7.0 supports disabling this warning.
• Ignore -Wc++14-compat since it warns about the sized new/delete overloads.

CMakeLists.txt

 # MSVC only has -X, which disables all default includes; including the crt.
 # Thus, we do nothing and hope we don't accidentally include any of the C++
 # headers
 add_compile_flags_if_supported(-nostdinc++)
 
 # Warning flags ===============================================================
 add_definitions(-D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 add_compile_flags_if_supported(
-    -Wall -W -Wwrite-strings
-    -Wno-unused-parameter -Wno-long-long -Wno-user-defined-literals
-    -Wno-covered-switch-default
+    -Wall -Wextra -W -Wwrite-strings
+    -Wno-unused-parameter -Wno-long-long
     -Werror=return-type)
+if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+    add_compile_flags_if_supported(
+        -Wno-user-defined-literals
+        -Wno-covered-switch-default)
+elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
+    add_compile_flags_if_supported(
+        -Wno-attributes # FIXME: Fix -Wattribute warnings.
+        -Wno-literal-suffix
+        -Wno-c++14-compat)
+endif()
 if (LIBCXX_ENABLE_WERROR)
   add_compile_flags_if_supported(-Werror)
   add_compile_flags_if_supported(-WX)
 else()
   # TODO(EricWF) Remove this. We shouldn't be suppressing errors when -Werror is
   # added elsewhere.
   add_compile_flags_if_supported(-Wno-error)
 endif()

include/__config

 #endif
 
 #ifdef __GNUC__
 #define _NOALIAS __attribute__((__malloc__))
 #else
 #define _NOALIAS
 #endif
 
+#ifdef __GNUC__
+#define _LIBCPP_MAY_ALIAS __attribute__((__may_alias__))
+#else
+#define _LIBCPP_MAY_ALIAS
+#endif
+
 #if __has_feature(cxx_explicit_conversions) || defined(__IBMCPP__)
 #   define _LIBCPP_EXPLICIT explicit
 #else
 #   define _LIBCPP_EXPLICIT
 #endif
 
 #if !__has_builtin(__builtin_operator_new) || !__has_builtin(__builtin_operator_delete)
 #   define _LIBCPP_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE

include/__tuple

 struct __make_tuple_types<__tuple_types<_Types...>, _Ep, 0, true> {
   typedef __tuple_types<_Types...> type;
 };
 
 template <bool ..._Preds>
 struct __all_dummy;
 
 template <bool ..._Pred>
-using __all = is_same<__all_dummy<_Pred...>, __all_dummy<(_Pred, true)...>>;
+using __all = is_same<__all_dummy<_Pred...>, __all_dummy<((void)_Pred, true)...>>;
 
 struct __tuple_sfinae_base {
   template <template <class, class...> class _Trait,
             class ..._LArgs, class ..._RArgs>
   static auto __do_test(__tuple_types<_LArgs...>, __tuple_types<_RArgs...>)
     -> __all<typename enable_if<_Trait<_LArgs, _RArgs>::value, bool>::type{true}...>;
   template <template <class...> class>
   static auto __do_test(...) -> false_type;

include/cstdlib

 
 #include <__config>
 #include <stdlib.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#ifdef __GNUC__
+#define _LIBCPP_UNREACHABLE() __builtin_unreachable()
+#else
+#define _LIBCPP_UNREACHABLE() _VSTD::abort()
+#endif
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 using ::size_t;
 using ::div_t;
 using ::ldiv_t;
 #ifndef _LIBCPP_HAS_NO_LONG_LONG
 using ::lldiv_t;
 #endif // _LIBCPP_HAS_NO_LONG_LONG

include/typeinfo

 
 namespace std  // purposefully not using versioning namespace
 {
 
 class _LIBCPP_EXCEPTION_ABI type_info
 {
     type_info& operator=(const type_info&);
     type_info(const type_info&);
+
+    typedef size_t _LIBCPP_MAY_ALIAS _ASizeT; // Avoid strict-aliasing issues.
+
 protected:
 #ifndef _LIBCPP_NONUNIQUE_RTTI_BIT
     const char* __type_name;
 #else
     // A const char* with the non-unique RTTI bit possibly set.
     uintptr_t __type_name;
 #endif
 
#else
         {if (!((__type_name & __arg.__type_name) & _LIBCPP_NONUNIQUE_RTTI_BIT))
            return __type_name < __arg.__type_name;
          return __compare_nonunique_names(__arg) < 0;}
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
     size_t hash_code() const _NOEXCEPT
 #ifndef _LIBCPP_NONUNIQUE_RTTI_BIT
-        {return *reinterpret_cast<const size_t*>(&__type_name);}
+        {return *reinterpret_cast<const _ASizeT *>(&__type_name);}
 #else
         {if (!(__type_name & _LIBCPP_NONUNIQUE_RTTI_BIT)) return __type_name;
          const char *__ptr = name();
          size_t __hash = 5381;
          while (unsigned char __c = static_cast<unsigned char>(*__ptr++))
            __hash = (__hash * 33) ^ __c;
          return __hash;}
 #endif

src/strstream.cpp

 //===------------------------ strstream.cpp -------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include "strstream"
 #include "algorithm"
 #include "climits"
 #include "cstring"
+#include "cstdlib"
 #include "__debug"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 strstreambuf::strstreambuf(streamsize __alsize)
     : __strmode_(__dynamic),
       __alsize_(__alsize),
       __palloc_(nullptr),
if (legal)
             newoff = 0;
             break;
         case ios::cur:
             newoff = (pos_in ? gptr() : pptr()) - eback();
             break;
         case ios::end:
             newoff = seekhigh - eback();
             break;
+        default:
+            _LIBCPP_UNREACHABLE();
         }
         newoff += __off;
         if (0 <= newoff && newoff <= seekhigh - eback())
         {
             char* newpos = eback() + newoff;
             if (pos_in)
                 setg(eback(), newpos, _VSTD::max(newpos, egptr()));
             if (pos_out)