AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Add missing explicit instantiation declarations

Browse Source 
This is a cosmetic change aimed to reduce compilation
time spent on instantiating things and potentially reduce
code (in case instantiated specializations are in
different shared objects).

Change-Id: I719b4d376a0d707f4724555a2f404327d19d8477
Reviewed-on: https://chromium-review.googlesource.com/c/1484298
Commit-Queue: Jakob Kummerow <jkummerow@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Reviewed-by: Michael Starzinger <mstarzinger@chromium.org>
Cr-Commit-Position: refs/heads/master@{#59988}
This commit is contained in:
Anton Bikineev 2019-02-24 01:09:41 +03:00 committed by Commit Bot
parent 9405fcfdd1
commit f8aaf984f7
6 changed files with 88 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
src/assert-scope.h
View File

@ -230,6 +230,35 @@ typedef PerIsolateAssertScopeDebugOnly<NO_EXCEPTION_ASSERT, false>
// Scope to introduce an exception to DisallowExceptions.
typedef PerIsolateAssertScopeDebugOnly<NO_EXCEPTION_ASSERT, true>
AllowExceptions;
// Explicit instantiation declarations.
extern template class PerThreadAssertScope<HEAP_ALLOCATION_ASSERT, false>;
extern template class PerThreadAssertScope<HEAP_ALLOCATION_ASSERT, true>;
extern template class PerThreadAssertScope<HANDLE_ALLOCATION_ASSERT, false>;
extern template class PerThreadAssertScope<HANDLE_ALLOCATION_ASSERT, true>;
extern template class PerThreadAssertScope<HANDLE_DEREFERENCE_ASSERT, false>;
extern template class PerThreadAssertScope<HANDLE_DEREFERENCE_ASSERT, true>;
extern template class PerThreadAssertScope<DEFERRED_HANDLE_DEREFERENCE_ASSERT,
false>;
extern template class PerThreadAssertScope<DEFERRED_HANDLE_DEREFERENCE_ASSERT,
true>;
extern template class PerThreadAssertScope<CODE_DEPENDENCY_CHANGE_ASSERT,
false>;
extern template class PerThreadAssertScope<CODE_DEPENDENCY_CHANGE_ASSERT, true>;
extern template class PerIsolateAssertScope<JAVASCRIPT_EXECUTION_ASSERT, false>;
extern template class PerIsolateAssertScope<JAVASCRIPT_EXECUTION_ASSERT, true>;
extern template class PerIsolateAssertScope<JAVASCRIPT_EXECUTION_THROWS, false>;
extern template class PerIsolateAssertScope<JAVASCRIPT_EXECUTION_THROWS, true>;
extern template class PerIsolateAssertScope<JAVASCRIPT_EXECUTION_DUMP, false>;
extern template class PerIsolateAssertScope<JAVASCRIPT_EXECUTION_DUMP, true>;
extern template class PerIsolateAssertScope<DEOPTIMIZATION_ASSERT, false>;
extern template class PerIsolateAssertScope<DEOPTIMIZATION_ASSERT, true>;
extern template class PerIsolateAssertScope<COMPILATION_ASSERT, false>;
extern template class PerIsolateAssertScope<COMPILATION_ASSERT, true>;
extern template class PerIsolateAssertScope<NO_EXCEPTION_ASSERT, false>;
extern template class PerIsolateAssertScope<NO_EXCEPTION_ASSERT, true>;
} // namespace internal
} // namespace v8

22
src/base/division-by-constant.cc
View File

@ -93,16 +93,22 @@ MagicNumbersForDivision<T> UnsignedDivisionByConstant(T d,
// -----------------------------------------------------------------------------
// Instantiations.
template struct V8_BASE_EXPORT MagicNumbersForDivision<uint32_t>;
template struct V8_BASE_EXPORT MagicNumbersForDivision<uint64_t>;
template struct EXPORT_TEMPLATE_DEFINE(V8_BASE_EXPORT)
MagicNumbersForDivision<uint32_t>;
template struct EXPORT_TEMPLATE_DEFINE(V8_BASE_EXPORT)
MagicNumbersForDivision<uint64_t>;
template MagicNumbersForDivision<uint32_t> SignedDivisionByConstant(uint32_t d);
template MagicNumbersForDivision<uint64_t> SignedDivisionByConstant(uint64_t d);
template EXPORT_TEMPLATE_DEFINE(V8_BASE_EXPORT)
MagicNumbersForDivision<uint32_t> SignedDivisionByConstant(uint32_t d);
template EXPORT_TEMPLATE_DEFINE(V8_BASE_EXPORT)
MagicNumbersForDivision<uint64_t> SignedDivisionByConstant(uint64_t d);
template MagicNumbersForDivision<uint32_t> UnsignedDivisionByConstant(
uint32_t d, unsigned leading_zeros);
template MagicNumbersForDivision<uint64_t> UnsignedDivisionByConstant(
uint64_t d, unsigned leading_zeros);
template EXPORT_TEMPLATE_DEFINE(V8_BASE_EXPORT)
MagicNumbersForDivision<uint32_t> UnsignedDivisionByConstant(
uint32_t d, unsigned leading_zeros);
template EXPORT_TEMPLATE_DEFINE(V8_BASE_EXPORT)
MagicNumbersForDivision<uint64_t> UnsignedDivisionByConstant(
uint64_t d, unsigned leading_zeros);
} // namespace base
} // namespace v8

33
src/base/division-by-constant.h
View File

@ -8,6 +8,7 @@
#include <stdint.h>
#include "src/base/base-export.h"
#include "src/base/export-template.h"
namespace v8 {
namespace base {
@ -18,7 +19,7 @@ namespace base {
// Delight", chapter 10. The template parameter must be one of the unsigned
// integral types.
template <class T>
struct V8_BASE_EXPORT MagicNumbersForDivision {
struct EXPORT_TEMPLATE_DECLARE(V8_BASE_EXPORT) MagicNumbersForDivision {
MagicNumbersForDivision(T m, unsigned s, bool a)
: multiplier(m), shift(s), add(a) {}
bool operator==(const MagicNumbersForDivision& rhs) const {
@ -34,25 +35,35 @@ struct V8_BASE_EXPORT MagicNumbersForDivision {
// Calculate the multiplier and shift for signed division via multiplication.
// The divisor must not be -1, 0 or 1 when interpreted as a signed value.
template <class T>
V8_BASE_EXPORT MagicNumbersForDivision<T> SignedDivisionByConstant(T d);
EXPORT_TEMPLATE_DECLARE(V8_BASE_EXPORT)
MagicNumbersForDivision<T> SignedDivisionByConstant(T d);
// Calculate the multiplier and shift for unsigned division via multiplication,
// see Warren's "Hacker's Delight", chapter 10. The divisor must not be 0 and
// leading_zeros can be used to speed up the calculation if the given number of
// upper bits of the dividend value are known to be zero.
template <class T>
V8_BASE_EXPORT MagicNumbersForDivision<T> UnsignedDivisionByConstant(
EXPORT_TEMPLATE_DECLARE(V8_BASE_EXPORT)
MagicNumbersForDivision<T> UnsignedDivisionByConstant(
T d, unsigned leading_zeros = 0);
extern template V8_BASE_EXPORT MagicNumbersForDivision<uint32_t>
SignedDivisionByConstant(uint32_t d);
extern template V8_BASE_EXPORT MagicNumbersForDivision<uint64_t>
SignedDivisionByConstant(uint64_t d);
// Explicit instantiation declarations.
extern template struct EXPORT_TEMPLATE_DECLARE(V8_BASE_EXPORT)
MagicNumbersForDivision<uint32_t>;
extern template struct EXPORT_TEMPLATE_DECLARE(V8_BASE_EXPORT)
MagicNumbersForDivision<uint64_t>;
extern template V8_BASE_EXPORT MagicNumbersForDivision<uint32_t>
UnsignedDivisionByConstant(uint32_t d, unsigned leading_zeros);
extern template V8_BASE_EXPORT MagicNumbersForDivision<uint64_t>
UnsignedDivisionByConstant(uint64_t d, unsigned leading_zeros);
extern template EXPORT_TEMPLATE_DECLARE(V8_BASE_EXPORT)
MagicNumbersForDivision<uint32_t> SignedDivisionByConstant(uint32_t d);
extern template EXPORT_TEMPLATE_DECLARE(V8_BASE_EXPORT)
MagicNumbersForDivision<uint64_t> SignedDivisionByConstant(uint64_t d);
extern template EXPORT_TEMPLATE_DECLARE(V8_BASE_EXPORT)
MagicNumbersForDivision<uint32_t> UnsignedDivisionByConstant(
uint32_t d, unsigned leading_zeros);
extern template EXPORT_TEMPLATE_DECLARE(V8_BASE_EXPORT)
MagicNumbersForDivision<uint64_t> UnsignedDivisionByConstant(
uint64_t d, unsigned leading_zeros);
} // namespace base
} // namespace v8

10
src/compiler/node-cache.cc
View File

@ -112,11 +112,13 @@ void NodeCache<Key, Hash, Pred>::GetCachedNodes(ZoneVector<Node*>* nodes) {
// -----------------------------------------------------------------------------
// Instantiations
template class V8_EXPORT_PRIVATE NodeCache<int32_t>;
template class V8_EXPORT_PRIVATE NodeCache<int64_t>;
template class EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE) NodeCache<int32_t>;
template class EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE) NodeCache<int64_t>;
template class V8_EXPORT_PRIVATE NodeCache<RelocInt32Key>;
template class V8_EXPORT_PRIVATE NodeCache<RelocInt64Key>;
template class EXPORT_TEMPLATE_DEFINE(
V8_EXPORT_PRIVATE) NodeCache<RelocInt32Key>;
template class EXPORT_TEMPLATE_DEFINE(
V8_EXPORT_PRIVATE) NodeCache<RelocInt64Key>;
} // namespace compiler
} // namespace internal

14
src/compiler/node-cache.h
View File

@ -5,6 +5,7 @@
#ifndef V8_COMPILER_NODE_CACHE_H_
#define V8_COMPILER_NODE_CACHE_H_
#include "src/base/export-template.h"
#include "src/base/functional.h"
#include "src/base/macros.h"
@ -27,7 +28,7 @@ class Node;
// nodes such as constants, parameters, etc.
template <typename Key, typename Hash = base::hash<Key>,
typename Pred = std::equal_to<Key> >
class V8_EXPORT_PRIVATE NodeCache final {
class EXPORT_TEMPLATE_DECLARE(V8_EXPORT_PRIVATE) NodeCache final {
public:
explicit NodeCache(unsigned max = 256)
: entries_(nullptr), size_(0), max_(max) {}
@ -77,6 +78,17 @@ typedef Int32NodeCache IntPtrNodeCache;
typedef Int64NodeCache IntPtrNodeCache;
#endif
// Explicit instantiation declarations.
extern template class EXPORT_TEMPLATE_DECLARE(
V8_EXPORT_PRIVATE) NodeCache<int32_t>;
extern template class EXPORT_TEMPLATE_DECLARE(
V8_EXPORT_PRIVATE) NodeCache<int64_t>;
extern template class EXPORT_TEMPLATE_DECLARE(
V8_EXPORT_PRIVATE) NodeCache<RelocInt32Key>;
extern template class EXPORT_TEMPLATE_DECLARE(
V8_EXPORT_PRIVATE) NodeCache<RelocInt64Key>;
} // namespace compiler
} // namespace internal
} // namespace v8

4
src/json-parser.h
View File

@ -157,6 +157,10 @@ class JsonParser {
ZoneVector<Handle<Object>> properties_;
};
// Explicit instantiation declarations.
extern template class JsonParser<true>;
extern template class JsonParser<false>;
} // namespace internal
} // namespace v8