scons: Enforce gcc >= 4.4 or clang >= 2.9 and c++0x support

This patch checks that the compiler in use is either gcc >= 4.4 or
clang >= 2.9. and enables building with --std=c++0x in all cases. As a
consequence, we can tidy up the hashmap and always have static_assert
available. If anyone wants to use alternative compilers, icc for
example supports c++0x to a similar level and could be added if
needed.

This patch opens up for a more elaborate use of c++0x features that
are present in gcc 4.4 and clang 2.9, e.g. auto typed variables,
variadic templates, rvalues and move semantics, and strongly typed
enums. There will be no going back on this one...

3 files changed, 8 insertions, 139 deletions

diff --git a/src/base/compiler.hh b/src/base/compiler.hh
index 33654fc11..7176537d2 100644
--- a/src/base/compiler.hh
+++ b/src/base/compiler.hh
@@ -43,8 +43,6 @@
 #ifndef __BASE_COMPILER_HH__
 #define __BASE_COMPILER_HH__
 
-#include "config/have_static_assert.hh"
-
 // http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
 
 #if defined(__GNUC__)
@@ -58,32 +56,4 @@
 #error "Need to define compiler options in base/compiler.hh"
 #endif
 
-/*
- * Define a compatibility macro that emulates the behavior of
- * static_assert using template magic if the compiler doesn't have
- * native support.
- */
-#if !HAVE_STATIC_ASSERT
-
-template<bool>
-struct static_assert_failure;
-
-template<>
-struct static_assert_failure<false> {};
-
-/* The following macro causes the compiler to evaluate the size of the
- * static_assert_failure struct. The templates are designed so that
- * only static_assert_failure<false> evaluates to a proper size, while
- * static_assert_failure<true> generates a compile time error.
- */
-#define static_assert(expr, msg)                                        \
-    namespace ns_static_assert {                                        \
-        enum {                                                          \
-            static_assert_ ## __LINE__ =                                \
-                sizeof(static_assert_failure<!(expr)>)                  \
-        };                                                              \
-    }
-
-#endif
-
 #endif // __BASE_COMPILER_HH__
diff --git a/src/base/hashmap.hh b/src/base/hashmap.hh
index 41de40055..fa9379ec4 100644
--- a/src/base/hashmap.hh
+++ b/src/base/hashmap.hh
@@ -44,100 +44,42 @@
 #ifndef __HASHMAP_HH__
 #define __HASHMAP_HH__
 
-#if defined(__GNUC__)
-
-// for compilers that deprecate ext/hash_map, i.e. gcc >= 4.3 and
-// clang, use unordered_map
-
-// we need to determine what is available, as in the non-c++0x case,
-// i.e. gcc == 4.3, the containers are in the std::tr1 namespace, and
-// only gcc >= 4.4 (with -std=c++0x) adds the final container
-// implementation in the std namespace
-
 #if defined(__clang__)
-// align with -std=c++0x only for clang >= 3.0 in CCFLAGS and also
-// check if the header is present as this depends on what clang was
-// built against, using XCode clang 3.1, for example, the header is
-// not present without adding -stdlib=libc++
-#if (__clang_major__ >= 3 && __has_include(<unordered_map>))
+// check if the header is present, which requires -stdlib=libc++, and
+// that in turn causes problems with incomplete template parameters
+#if (__has_include(<unordered_map>))
 #define HAVE_STD_UNORDERED_MAP 1
-#else
-// we only support clang versions above 2.9 and these all have the tr1
-// unordered_map
-#define HAVE_STD_TR1_UNORDERED_MAP 1
 #endif
 #else
-// align with -std=c++0x only for gcc >= 4.4 in CCFLAGS, contrary to
-// clang we can rely entirely on the compiler version
-#if ((__GNUC__ == 4 && __GNUC_MINOR__ >= 4) || __GNUC__ > 4)
+// we only support gcc >= 4.4 as the other option
 #define HAVE_STD_UNORDERED_MAP 1
-#else
-#define HAVE_STD_TR1_UNORDERED_MAP 1
-#endif
 #endif
 
-// set a default value of 0
+// set a default value of 0 clang with the header in the tr1 namespace
 #ifndef HAVE_STD_UNORDERED_MAP
 #define HAVE_STD_UNORDERED_MAP 0
 #endif
 
-// set a default value of 0
-#ifndef HAVE_STD_TR1_UNORDERED_MAP
-#define HAVE_STD_TR1_UNORDERED_MAP 0
-#endif
-
-// now we are ready to deal with the actual includes based on what is
-// available
-#if (HAVE_STD_UNORDERED_MAP || HAVE_STD_TR1_UNORDERED_MAP)
-
 #define hash_map unordered_map
 #define hash_multimap unordered_multimap
 #define hash_set unordered_set
 #define hash_multiset unordered_multiset
 
-// these versions also have an existing hash function for strings and
-// 64-bit integer types
-#define HAVE_HASH_FUNCTIONS 1
-
 #if HAVE_STD_UNORDERED_MAP
-
-// clang or gcc >= 4.4
+// gcc or clang with libc++
 #include <unordered_map>
 #include <unordered_set>
-// note that this assumes that -std=c++0x is added to the command line
-// which is done in the SConstruct CXXFLAGS for gcc >= 4.4 and clang
-// >= 3.0
 #define __hash_namespace std
 #define __hash_namespace_begin namespace std {
 #define __hash_namespace_end }
 #else
-// clang <= 3.0, gcc == 4.3
+// clang with libstdc++
 #include <tr1/unordered_map>
 #include <tr1/unordered_set>
 #define __hash_namespace std::tr1
 #define __hash_namespace_begin namespace std { namespace tr1 {
 #define __hash_namespace_end } }
 #endif
-#else
-// gcc < 4.3
-#include <ext/hash_map>
-#include <ext/hash_set>
-#define __hash_namespace __gnu_cxx
-#define __hash_namespace_begin namespace __gnu_cxx {
-#define __hash_namespace_end }
-#endif
-#else
-// non GNU compiler
-#include <hash_map>
-#include <hash_set>
-#define __hash_namsepace std
-#define __hash_namespace_begin namespace std {
-#define __hash_namespace_end }
-#endif
-
-#include <string>
-
-#include "base/types.hh"
 
 namespace m5 {
     using ::__hash_namespace::hash_multimap;
@@ -147,47 +89,4 @@ namespace m5 {
     using ::__hash_namespace::hash;
 }
 
-
-///////////////////////////////////
-// Some default Hashing Functions
-//
-
-__hash_namespace_begin
-
-// if the hash functions for 64-bit integer types and strings are not
-// already available, then declare them here
-#if !defined(HAVE_HASH_FUNCTIONS)
-
-#if !defined(__LP64__) && !defined(__alpha__) && !defined(__SUNPRO_CC)
-    template<>
-    struct hash<uint64_t> {
-        size_t operator()(uint64_t r) const {
-            return r;
-        }
-    };
-
-    template<>
-    struct hash<int64_t> {
-        size_t operator()(int64_t r) const {
-            return r;
-        };
-    };
-#endif
-
-    template<>
-    struct hash<std::string> {
-        size_t operator()(const std::string &s) const {
-            return(__stl_hash_string(s.c_str()));
-        }
-    };
-
-    template <>
-    struct hash<std::pair<std::string, uint64_t> > {
-        size_t operator() (std::pair<std::string, uint64_t> r) const {
-            return (__stl_hash_string(r.first.c_str())) ^ r.second;
-        }
-    };
-#endif
-__hash_namespace_end
-
 #endif // __HASHMAP_HH__
diff --git a/src/base/stats/text.cc b/src/base/stats/text.cc
index 3d80e367c..870b16f79 100644
--- a/src/base/stats/text.cc
+++ b/src/base/stats/text.cc
@@ -223,7 +223,7 @@ ScalarPrint::operator()(ostream &stream) const
         ccprintf(cdfstr, "%.2f%%", cdf * 100.0);
 
     ccprintf(stream, "%-40s %12s %10s %10s", name,
-             ValueToString(value, precision), pdfstr, cdfstr);
+             ValueToString(value, precision), pdfstr.str(), cdfstr.str());
 
     if (descriptions) {
         if (!desc.empty())