Reland "Turn libbase into a component"

src/base/functional.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_BASE_FUNCTIONAL_H_
 #define V8_BASE_FUNCTIONAL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cstddef>
 #include <cstring>
 #include <functional>
 #include <utility>
 
+#include "src/base/base-export.h"
 #include "src/base/macros.h"
 
 namespace v8 {
 namespace base {
 
 // base::hash is an implementation of the hash function object specified by
 // C++11. It was designed to be compatible with std::hash (in C++11) and
 // boost:hash (which in turn is based on the hash function object specified by
 // the Draft Technical Report on C++ Library Extensions (TR1)).
 //
@@ skipping 34 matching lines @@
 // Based on the "Hashing User-Defined Types in C++1y" proposal from Jeffrey
 // Yasskin and Chandler Carruth, see
 // http://www.open-std.org/Jtc1/sc22/wg21/docs/papers/2012/n3333.html.
 
 template <typename>
 struct hash;
 
 
 V8_INLINE size_t hash_combine() { return 0u; }
 V8_INLINE size_t hash_combine(size_t seed) { return seed; }
-size_t hash_combine(size_t seed, size_t value);
+V8_BASE_EXPORT size_t hash_combine(size_t seed, size_t value);
 template <typename T, typename... Ts>
 V8_INLINE size_t hash_combine(T const& v, Ts const&... vs) {
   return hash_combine(hash_combine(vs...), hash<T>()(v));
 }
 
 
 template <typename Iterator>
 V8_INLINE size_t hash_range(Iterator first, Iterator last) {
   size_t seed = 0;
   for (; first != last; ++first) {
     seed = hash_combine(seed, *first);
   }
   return seed;
 }
 
 
 #define V8_BASE_HASH_VALUE_TRIVIAL(type) \
   V8_INLINE size_t hash_value(type v) { return static_cast<size_t>(v); }
 V8_BASE_HASH_VALUE_TRIVIAL(bool)
 V8_BASE_HASH_VALUE_TRIVIAL(unsigned char)
 V8_BASE_HASH_VALUE_TRIVIAL(unsigned short)  // NOLINT(runtime/int)
 #undef V8_BASE_HASH_VALUE_TRIVIAL
 
-size_t hash_value(unsigned int);
-size_t hash_value(unsigned long);       // NOLINT(runtime/int)
-size_t hash_value(unsigned long long);  // NOLINT(runtime/int)
+V8_BASE_EXPORT size_t hash_value(unsigned int);
+V8_BASE_EXPORT size_t hash_value(unsigned long);       // NOLINT(runtime/int)
+V8_BASE_EXPORT size_t hash_value(unsigned long long);  // NOLINT(runtime/int)
 
 #define V8_BASE_HASH_VALUE_SIGNED(type)            \
   V8_INLINE size_t hash_value(signed type v) {     \
     return hash_value(bit_cast<unsigned type>(v)); \
   }
 V8_BASE_HASH_VALUE_SIGNED(char)
 V8_BASE_HASH_VALUE_SIGNED(short)      // NOLINT(runtime/int)
 V8_BASE_HASH_VALUE_SIGNED(int)        // NOLINT(runtime/int)
 V8_BASE_HASH_VALUE_SIGNED(long)       // NOLINT(runtime/int)
 V8_BASE_HASH_VALUE_SIGNED(long long)  // NOLINT(runtime/int)
@@ skipping 111 matching lines @@
     }                                                                         \
   };
 V8_BASE_BIT_SPECIALIZE_BIT_CAST(float, uint32_t)
 V8_BASE_BIT_SPECIALIZE_BIT_CAST(double, uint64_t)
 #undef V8_BASE_BIT_SPECIALIZE_BIT_CAST
 
 }  // namespace base
 }  // namespace v8
 
 #endif  // V8_BASE_FUNCTIONAL_H_