# Set up default C++ compiler flags
if main['GCC']:
+ # Check for a supported version of gcc, >= 4.4 is needed for c++0x
+ # support. See http://gcc.gnu.org/projects/cxx0x.html for details
+ gcc_version = readCommand([main['CXX'], '-dumpversion'], exception=False)
+ if compareVersions(gcc_version, "4.4") < 0:
+ print 'Error: gcc version 4.4 or newer required.'
+ print ' Installed version:', gcc_version
+ Exit(1)
+
+ main['GCC_VERSION'] = gcc_version
main.Append(CCFLAGS=['-pipe'])
main.Append(CCFLAGS=['-fno-strict-aliasing'])
main.Append(CCFLAGS=['-Wall', '-Wno-sign-compare', '-Wundef'])
- # Read the GCC version to check for versions with bugs
- # Note CCVERSION doesn't work here because it is run with the CC
- # before we override it from the command line
- gcc_version = readCommand([main['CXX'], '-dumpversion'], exception=False)
- main['GCC_VERSION'] = gcc_version
+ main.Append(CXXFLAGS=['-std=c++0x'])
+
+ # Check for versions with bugs
if not compareVersions(gcc_version, '4.4.1') or \
not compareVersions(gcc_version, '4.4.2'):
print 'Info: Tree vectorizer in GCC 4.4.1 & 4.4.2 is buggy, disabling.'
main.Append(CCFLAGS=['-fno-tree-vectorize'])
- # c++0x support in gcc is useful already from 4.4, see
- # http://gcc.gnu.org/projects/cxx0x.html for details
- if compareVersions(gcc_version, '4.4') >= 0:
- main.Append(CXXFLAGS=['-std=c++0x'])
# LTO support is only really working properly from 4.6 and beyond
if compareVersions(gcc_version, '4.6') >= 0:
'-fuse-linker-plugin']
elif main['CLANG']:
+ # Check for a supported version of clang, >= 2.9 is needed to
+ # support similar features as gcc 4.4. See
+ # http://clang.llvm.org/cxx_status.html for details
clang_version_re = re.compile(".* version (\d+\.\d+)")
clang_version_match = clang_version_re.match(CXX_version)
if (clang_version_match):
# Ruby makes frequent use of extraneous parantheses in the printing
# of if-statements
main.Append(CCFLAGS=['-Wno-parentheses'])
+ main.Append(CXXFLAGS=['-std=c++0x'])
+ # On Mac OS X/Darwin we need to also use libc++ (part of XCode) as
+ # opposed to libstdc++ to make the transition from TR1 to
+ # C++11. See http://libcxx.llvm.org. However, clang has chosen a
+ # strict implementation of the C++11 standard, and does not allow
+ # incomplete types in template arguments (besides unique_ptr and
+ # shared_ptr), and the libc++ STL containers create problems in
+ # combination with the current gem5 code. For now, we stick with
+ # libstdc++ and use the TR1 namespace.
+ # if sys.platform == "darwin":
+ # main.Append(CXXFLAGS=['-stdlib=libc++'])
- # clang 2.9 does not play well with c++0x as it ships with C++
- # headers that produce errors, this was fixed in 3.0
- if compareVersions(clang_version, "3") >= 0:
- main.Append(CXXFLAGS=['-std=c++0x'])
else:
print termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal,
print "Don't know what compiler options to use for your compiler."
context.Result(ret)
return ret
-# Test for the presence of C++11 static asserts. If the compiler lacks
-# support for static asserts, base/compiler.hh enables a macro that
-# removes any static asserts in the code.
-def CheckStaticAssert(context):
- context.Message("Checking for C++11 static_assert support...")
- ret = context.TryCompile('''
- static_assert(1, "This assert is always true");
- ''', extension=".cc")
- context.env.Append(HAVE_STATIC_ASSERT=ret)
- context.Result(ret)
- return ret
-
# Platform-specific configuration. Note again that we assume that all
# builds under a given build root run on the same host platform.
conf = Configure(main,
conf_dir = joinpath(build_root, '.scons_config'),
log_file = joinpath(build_root, 'scons_config.log'),
- custom_tests = { 'CheckLeading' : CheckLeading,
- 'CheckStaticAssert' : CheckStaticAssert,
- })
+ custom_tests = { 'CheckLeading' : CheckLeading })
# Check for leading underscores. Don't really need to worry either
# way so don't need to check the return code.
conf.CheckLeading()
-# Check for C++11 features we want to use if they exist
-conf.CheckStaticAssert()
-
# Check if we should compile a 64 bit binary on Mac OS X/Darwin
try:
import platform
)
# These variables get exported to #defines in config/*.hh (see src/SConscript).
-export_vars += ['USE_FENV', 'SS_COMPATIBLE_FP',
- 'TARGET_ISA', 'CP_ANNOTATE', 'USE_POSIX_CLOCK', 'PROTOCOL',
- 'HAVE_STATIC_ASSERT', 'HAVE_PROTOBUF']
+export_vars += ['USE_FENV', 'SS_COMPATIBLE_FP', 'TARGET_ISA', 'CP_ANNOTATE',
+ 'USE_POSIX_CLOCK', 'PROTOCOL', 'HAVE_PROTOBUF']
###################################################
#
m4env = main.Clone()
if m4env['GCC']:
- if compareVersions(m4env['GCC_VERSION'], '4') >= 0:
- m4env.Append(CCFLAGS=['-Wno-pointer-sign'])
+ m4env.Append(CCFLAGS=['-Wno-pointer-sign'])
if compareVersions(m4env['GCC_VERSION'], '4.6') >= 0:
m4env.Append(CCFLAGS=['-Wno-unused-but-set-variable',
'-Wno-implicit-function-declaration'])
#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__)
#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__
#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;
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__
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())
projects / gem5.git / commitdiff