v8/src/external-reference-table.cc
bmeurer 93e26314af [builtins] Introduce proper Float64Exp operator.
Import base::ieee754::exp() from FreeBSD msun and introduce a Float64Exp
TurboFan operator based on that, similar to what we do for Float64Log.
Rewrite Math.exp() as TurboFan builtin and use that operator to also
inline Math.exp() into optimized TurboFan functions.

BUG=v8:3266,v8:3468,v8:3493,v8:5086,v8:5108
R=mvstanton@chromium.org

Review-Url: https://codereview.chromium.org/2077533002
Cr-Commit-Position: refs/heads/master@{#37037}
2016-06-16 12:10:27 +00:00

381 lines
16 KiB
C++

// Copyright 2016 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.
#include "src/external-reference-table.h"
#include "src/accessors.h"
#include "src/assembler.h"
#include "src/counters.h"
#include "src/deoptimizer.h"
#include "src/ic/stub-cache.h"
namespace v8 {
namespace internal {
ExternalReferenceTable* ExternalReferenceTable::instance(Isolate* isolate) {
ExternalReferenceTable* external_reference_table =
isolate->external_reference_table();
if (external_reference_table == NULL) {
external_reference_table = new ExternalReferenceTable(isolate);
isolate->set_external_reference_table(external_reference_table);
}
return external_reference_table;
}
ExternalReferenceTable::ExternalReferenceTable(Isolate* isolate) {
// Miscellaneous
Add(ExternalReference::roots_array_start(isolate).address(),
"Heap::roots_array_start()");
Add(ExternalReference::address_of_stack_limit(isolate).address(),
"StackGuard::address_of_jslimit()");
Add(ExternalReference::address_of_real_stack_limit(isolate).address(),
"StackGuard::address_of_real_jslimit()");
Add(ExternalReference::new_space_allocation_limit_address(isolate).address(),
"Heap::NewSpaceAllocationLimitAddress()");
Add(ExternalReference::new_space_allocation_top_address(isolate).address(),
"Heap::NewSpaceAllocationTopAddress()");
Add(ExternalReference::mod_two_doubles_operation(isolate).address(),
"mod_two_doubles");
// Keyed lookup cache.
Add(ExternalReference::keyed_lookup_cache_keys(isolate).address(),
"KeyedLookupCache::keys()");
Add(ExternalReference::keyed_lookup_cache_field_offsets(isolate).address(),
"KeyedLookupCache::field_offsets()");
Add(ExternalReference::handle_scope_next_address(isolate).address(),
"HandleScope::next");
Add(ExternalReference::handle_scope_limit_address(isolate).address(),
"HandleScope::limit");
Add(ExternalReference::handle_scope_level_address(isolate).address(),
"HandleScope::level");
Add(ExternalReference::new_deoptimizer_function(isolate).address(),
"Deoptimizer::New()");
Add(ExternalReference::compute_output_frames_function(isolate).address(),
"Deoptimizer::ComputeOutputFrames()");
Add(ExternalReference::address_of_min_int().address(),
"LDoubleConstant::min_int");
Add(ExternalReference::address_of_one_half().address(),
"LDoubleConstant::one_half");
Add(ExternalReference::isolate_address(isolate).address(), "isolate");
Add(ExternalReference::interpreter_dispatch_table_address(isolate).address(),
"Interpreter::dispatch_table_address");
Add(ExternalReference::interpreter_dispatch_counters(isolate).address(),
"Interpreter::interpreter_dispatch_counters");
Add(ExternalReference::address_of_negative_infinity().address(),
"LDoubleConstant::negative_infinity");
Add(ExternalReference::power_double_double_function(isolate).address(),
"power_double_double_function");
Add(ExternalReference::power_double_int_function(isolate).address(),
"power_double_int_function");
Add(ExternalReference::ieee754_atan_function(isolate).address(),
"base::ieee754::atan");
Add(ExternalReference::ieee754_atan2_function(isolate).address(),
"base::ieee754::atan2");
Add(ExternalReference::ieee754_exp_function(isolate).address(),
"base::ieee754::exp");
Add(ExternalReference::ieee754_log_function(isolate).address(),
"base::ieee754::log");
Add(ExternalReference::ieee754_log1p_function(isolate).address(),
"base::ieee754::log1p");
Add(ExternalReference::ieee754_log2_function(isolate).address(),
"base::ieee754::log2");
Add(ExternalReference::ieee754_log10_function(isolate).address(),
"base::ieee754::log10");
Add(ExternalReference::store_buffer_top(isolate).address(),
"store_buffer_top");
Add(ExternalReference::address_of_the_hole_nan().address(), "the_hole_nan");
Add(ExternalReference::get_date_field_function(isolate).address(),
"JSDate::GetField");
Add(ExternalReference::date_cache_stamp(isolate).address(),
"date_cache_stamp");
Add(ExternalReference::address_of_pending_message_obj(isolate).address(),
"address_of_pending_message_obj");
Add(ExternalReference::get_make_code_young_function(isolate).address(),
"Code::MakeCodeYoung");
Add(ExternalReference::cpu_features().address(), "cpu_features");
Add(ExternalReference::old_space_allocation_top_address(isolate).address(),
"Heap::OldSpaceAllocationTopAddress");
Add(ExternalReference::old_space_allocation_limit_address(isolate).address(),
"Heap::OldSpaceAllocationLimitAddress");
Add(ExternalReference::allocation_sites_list_address(isolate).address(),
"Heap::allocation_sites_list_address()");
Add(ExternalReference::address_of_uint32_bias().address(), "uint32_bias");
Add(ExternalReference::get_mark_code_as_executed_function(isolate).address(),
"Code::MarkCodeAsExecuted");
Add(ExternalReference::is_profiling_address(isolate).address(),
"Isolate::is_profiling");
Add(ExternalReference::scheduled_exception_address(isolate).address(),
"Isolate::scheduled_exception");
Add(ExternalReference::invoke_function_callback(isolate).address(),
"InvokeFunctionCallback");
Add(ExternalReference::invoke_accessor_getter_callback(isolate).address(),
"InvokeAccessorGetterCallback");
Add(ExternalReference::wasm_f32_trunc(isolate).address(),
"wasm::f32_trunc_wrapper");
Add(ExternalReference::wasm_f32_floor(isolate).address(),
"wasm::f32_floor_wrapper");
Add(ExternalReference::wasm_f32_ceil(isolate).address(),
"wasm::f32_ceil_wrapper");
Add(ExternalReference::wasm_f32_nearest_int(isolate).address(),
"wasm::f32_nearest_int_wrapper");
Add(ExternalReference::wasm_f64_trunc(isolate).address(),
"wasm::f64_trunc_wrapper");
Add(ExternalReference::wasm_f64_floor(isolate).address(),
"wasm::f64_floor_wrapper");
Add(ExternalReference::wasm_f64_ceil(isolate).address(),
"wasm::f64_ceil_wrapper");
Add(ExternalReference::wasm_f64_nearest_int(isolate).address(),
"wasm::f64_nearest_int_wrapper");
Add(ExternalReference::wasm_int64_to_float32(isolate).address(),
"wasm::int64_to_float32_wrapper");
Add(ExternalReference::wasm_uint64_to_float32(isolate).address(),
"wasm::uint64_to_float32_wrapper");
Add(ExternalReference::wasm_int64_to_float64(isolate).address(),
"wasm::int64_to_float64_wrapper");
Add(ExternalReference::wasm_uint64_to_float64(isolate).address(),
"wasm::uint64_to_float64_wrapper");
Add(ExternalReference::wasm_float32_to_int64(isolate).address(),
"wasm::float32_to_int64_wrapper");
Add(ExternalReference::wasm_float32_to_uint64(isolate).address(),
"wasm::float32_to_uint64_wrapper");
Add(ExternalReference::wasm_float64_to_int64(isolate).address(),
"wasm::float64_to_int64_wrapper");
Add(ExternalReference::wasm_float64_to_uint64(isolate).address(),
"wasm::float64_to_uint64_wrapper");
Add(ExternalReference::wasm_int64_div(isolate).address(), "wasm::int64_div");
Add(ExternalReference::wasm_int64_mod(isolate).address(), "wasm::int64_mod");
Add(ExternalReference::wasm_uint64_div(isolate).address(),
"wasm::uint64_div");
Add(ExternalReference::wasm_uint64_mod(isolate).address(),
"wasm::uint64_mod");
Add(ExternalReference::wasm_word32_ctz(isolate).address(),
"wasm::word32_ctz");
Add(ExternalReference::wasm_word64_ctz(isolate).address(),
"wasm::word64_ctz");
Add(ExternalReference::wasm_word32_popcnt(isolate).address(),
"wasm::word32_popcnt");
Add(ExternalReference::wasm_word64_popcnt(isolate).address(),
"wasm::word64_popcnt");
Add(ExternalReference::f64_acos_wrapper_function(isolate).address(),
"f64_acos_wrapper");
Add(ExternalReference::f64_asin_wrapper_function(isolate).address(),
"f64_asin_wrapper");
Add(ExternalReference::f64_cos_wrapper_function(isolate).address(),
"f64_cos_wrapper");
Add(ExternalReference::f64_sin_wrapper_function(isolate).address(),
"f64_sin_wrapper");
Add(ExternalReference::f64_tan_wrapper_function(isolate).address(),
"f64_tan_wrapper");
Add(ExternalReference::f64_exp_wrapper_function(isolate).address(),
"f64_exp_wrapper");
Add(ExternalReference::f64_pow_wrapper_function(isolate).address(),
"f64_pow_wrapper");
Add(ExternalReference::f64_mod_wrapper_function(isolate).address(),
"f64_mod_wrapper");
Add(ExternalReference::log_enter_external_function(isolate).address(),
"Logger::EnterExternal");
Add(ExternalReference::log_leave_external_function(isolate).address(),
"Logger::LeaveExternal");
Add(ExternalReference::address_of_minus_one_half().address(),
"double_constants.minus_one_half");
Add(ExternalReference::stress_deopt_count(isolate).address(),
"Isolate::stress_deopt_count_address()");
Add(ExternalReference::virtual_handler_register(isolate).address(),
"Isolate::virtual_handler_register()");
Add(ExternalReference::virtual_slot_register(isolate).address(),
"Isolate::virtual_slot_register()");
Add(ExternalReference::runtime_function_table_address(isolate).address(),
"Runtime::runtime_function_table_address()");
Add(ExternalReference::is_tail_call_elimination_enabled_address(isolate)
.address(),
"Isolate::is_tail_call_elimination_enabled_address()");
// Debug addresses
Add(ExternalReference::debug_after_break_target_address(isolate).address(),
"Debug::after_break_target_address()");
Add(ExternalReference::debug_is_active_address(isolate).address(),
"Debug::is_active_address()");
Add(ExternalReference::debug_last_step_action_address(isolate).address(),
"Debug::step_in_enabled_address()");
Add(ExternalReference::debug_suspended_generator_address(isolate).address(),
"Debug::step_suspended_generator_address()");
#ifndef V8_INTERPRETED_REGEXP
Add(ExternalReference::re_case_insensitive_compare_uc16(isolate).address(),
"NativeRegExpMacroAssembler::CaseInsensitiveCompareUC16()");
Add(ExternalReference::re_check_stack_guard_state(isolate).address(),
"RegExpMacroAssembler*::CheckStackGuardState()");
Add(ExternalReference::re_grow_stack(isolate).address(),
"NativeRegExpMacroAssembler::GrowStack()");
Add(ExternalReference::re_word_character_map().address(),
"NativeRegExpMacroAssembler::word_character_map");
Add(ExternalReference::address_of_regexp_stack_limit(isolate).address(),
"RegExpStack::limit_address()");
Add(ExternalReference::address_of_regexp_stack_memory_address(isolate)
.address(),
"RegExpStack::memory_address()");
Add(ExternalReference::address_of_regexp_stack_memory_size(isolate).address(),
"RegExpStack::memory_size()");
Add(ExternalReference::address_of_static_offsets_vector(isolate).address(),
"OffsetsVector::static_offsets_vector");
#endif // V8_INTERPRETED_REGEXP
// The following populates all of the different type of external references
// into the ExternalReferenceTable.
//
// NOTE: This function was originally 100k of code. It has since been
// rewritten to be mostly table driven, as the callback macro style tends to
// very easily cause code bloat. Please be careful in the future when adding
// new references.
struct RefTableEntry {
uint16_t id;
const char* name;
};
static const RefTableEntry c_builtins[] = {
#define DEF_ENTRY_C(name, ignored) {Builtins::c_##name, "Builtins::" #name},
BUILTIN_LIST_C(DEF_ENTRY_C)
#undef DEF_ENTRY_C
};
for (unsigned i = 0; i < arraysize(c_builtins); ++i) {
ExternalReference ref(static_cast<Builtins::CFunctionId>(c_builtins[i].id),
isolate);
Add(ref.address(), c_builtins[i].name);
}
static const RefTableEntry builtins[] = {
#define DEF_ENTRY_C(name, ignored) {Builtins::k##name, "Builtins::" #name},
#define DEF_ENTRY_A(name, i1, i2) {Builtins::k##name, "Builtins::" #name},
BUILTIN_LIST_C(DEF_ENTRY_C) BUILTIN_LIST_A(DEF_ENTRY_A)
BUILTIN_LIST_DEBUG_A(DEF_ENTRY_A)
#undef DEF_ENTRY_C
#undef DEF_ENTRY_A
};
for (unsigned i = 0; i < arraysize(builtins); ++i) {
ExternalReference ref(static_cast<Builtins::Name>(builtins[i].id), isolate);
Add(ref.address(), builtins[i].name);
}
static const RefTableEntry runtime_functions[] = {
#define RUNTIME_ENTRY(name, i1, i2) {Runtime::k##name, "Runtime::" #name},
FOR_EACH_INTRINSIC(RUNTIME_ENTRY)
#undef RUNTIME_ENTRY
};
for (unsigned i = 0; i < arraysize(runtime_functions); ++i) {
ExternalReference ref(
static_cast<Runtime::FunctionId>(runtime_functions[i].id), isolate);
Add(ref.address(), runtime_functions[i].name);
}
// Stat counters
struct StatsRefTableEntry {
StatsCounter* (Counters::*counter)();
const char* name;
};
static const StatsRefTableEntry stats_ref_table[] = {
#define COUNTER_ENTRY(name, caption) {&Counters::name, "Counters::" #name},
STATS_COUNTER_LIST_1(COUNTER_ENTRY) STATS_COUNTER_LIST_2(COUNTER_ENTRY)
#undef COUNTER_ENTRY
};
Counters* counters = isolate->counters();
for (unsigned i = 0; i < arraysize(stats_ref_table); ++i) {
// To make sure the indices are not dependent on whether counters are
// enabled, use a dummy address as filler.
Address address = NotAvailable();
StatsCounter* counter = (counters->*(stats_ref_table[i].counter))();
if (counter->Enabled()) {
address = reinterpret_cast<Address>(counter->GetInternalPointer());
}
Add(address, stats_ref_table[i].name);
}
// Top addresses
static const char* address_names[] = {
#define BUILD_NAME_LITERAL(Name, name) "Isolate::" #name "_address",
FOR_EACH_ISOLATE_ADDRESS_NAME(BUILD_NAME_LITERAL) NULL
#undef BUILD_NAME_LITERAL
};
for (int i = 0; i < Isolate::kIsolateAddressCount; ++i) {
Add(isolate->get_address_from_id(static_cast<Isolate::AddressId>(i)),
address_names[i]);
}
// Accessors
struct AccessorRefTable {
Address address;
const char* name;
};
static const AccessorRefTable getters[] = {
#define ACCESSOR_INFO_DECLARATION(name) \
{FUNCTION_ADDR(&Accessors::name##Getter), "Accessors::" #name "Getter"},
ACCESSOR_INFO_LIST(ACCESSOR_INFO_DECLARATION)
#undef ACCESSOR_INFO_DECLARATION
};
static const AccessorRefTable setters[] = {
#define ACCESSOR_SETTER_DECLARATION(name) \
{FUNCTION_ADDR(&Accessors::name), "Accessors::" #name},
ACCESSOR_SETTER_LIST(ACCESSOR_SETTER_DECLARATION)
#undef ACCESSOR_INFO_DECLARATION
};
for (unsigned i = 0; i < arraysize(getters); ++i) {
Add(getters[i].address, getters[i].name);
Add(AccessorInfo::redirect(isolate, getters[i].address, ACCESSOR_GETTER),
"");
}
for (unsigned i = 0; i < arraysize(setters); ++i) {
Add(setters[i].address, setters[i].name);
}
StubCache* stub_cache = isolate->stub_cache();
// Stub cache tables
Add(stub_cache->key_reference(StubCache::kPrimary).address(),
"StubCache::primary_->key");
Add(stub_cache->value_reference(StubCache::kPrimary).address(),
"StubCache::primary_->value");
Add(stub_cache->map_reference(StubCache::kPrimary).address(),
"StubCache::primary_->map");
Add(stub_cache->key_reference(StubCache::kSecondary).address(),
"StubCache::secondary_->key");
Add(stub_cache->value_reference(StubCache::kSecondary).address(),
"StubCache::secondary_->value");
Add(stub_cache->map_reference(StubCache::kSecondary).address(),
"StubCache::secondary_->map");
// Runtime entries
Add(ExternalReference::delete_handle_scope_extensions(isolate).address(),
"HandleScope::DeleteExtensions");
Add(ExternalReference::incremental_marking_record_write_function(isolate)
.address(),
"IncrementalMarking::RecordWrite");
Add(ExternalReference::incremental_marking_record_write_code_entry_function(
isolate)
.address(),
"IncrementalMarking::RecordWriteOfCodeEntryFromCode");
Add(ExternalReference::store_buffer_overflow_function(isolate).address(),
"StoreBuffer::StoreBufferOverflow");
// Add a small set of deopt entry addresses to encoder without generating the
// deopt table code, which isn't possible at deserialization time.
HandleScope scope(isolate);
for (int entry = 0; entry < kDeoptTableSerializeEntryCount; ++entry) {
Address address = Deoptimizer::GetDeoptimizationEntry(
isolate, entry, Deoptimizer::LAZY,
Deoptimizer::CALCULATE_ENTRY_ADDRESS);
Add(address, "lazy_deopt");
}
}
} // namespace internal
} // namespace v8