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

[builtins] Move several CodeStub-based ICs to builtins

Browse Source 
This CL is from danno@chromium.org. Moves code stubs

LoadIC
KeyedLoadICTF
StoreIC
KeyedStoreICTF
LoadICTrampoline
KeyedLoadICTrampolineTF
StoreICTrampoline
KeyedStoreICTrampolineTF

into builtins.

TBR Yang for serializer changes.

R=epertoso@chromium.org
TBR=yangguo@chromium.org
BUG=

Review-Url: https://codereview.chromium.org/2608883002
Cr-Commit-Position: refs/heads/master@{#42001}
This commit is contained in:
mvstanton 2016-12-30 02:31:01 -08:00 committed by Commit bot
parent 2077b314d5
commit 92d8d95575
13 changed files with 130 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
BUILD.gn
View File

@ -955,6 +955,7 @@ v8_source_set("v8_base") {
"src/builtins/builtins-generator.cc",
"src/builtins/builtins-global.cc",
"src/builtins/builtins-handler.cc",
"src/builtins/builtins-ic.cc",
"src/builtins/builtins-internal.cc",
"src/builtins/builtins-interpreter.cc",
"src/builtins/builtins-json.cc",

62
src/builtins/builtins-ic.cc Normal file
View File

@ -0,0 +1,62 @@
// 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/builtins/builtins-utils.h"
#include "src/builtins/builtins.h"
#include "src/code-stub-assembler.h"
#include "src/ic/accessor-assembler.h"
namespace v8 {
namespace internal {
TF_BUILTIN(LoadIC, CodeStubAssembler) {
AccessorAssembler::GenerateLoadIC(state());
}
TF_BUILTIN(KeyedLoadIC, CodeStubAssembler) {
AccessorAssembler::GenerateKeyedLoadICTF(state());
}
TF_BUILTIN(LoadICTrampoline, CodeStubAssembler) {
AccessorAssembler::GenerateLoadICTrampoline(state());
}
TF_BUILTIN(KeyedLoadICTrampoline, CodeStubAssembler) {
AccessorAssembler::GenerateKeyedLoadICTrampolineTF(state());
}
TF_BUILTIN(StoreIC, CodeStubAssembler) {
AccessorAssembler::GenerateStoreIC(state());
}
TF_BUILTIN(StoreICTrampoline, CodeStubAssembler) {
AccessorAssembler::GenerateStoreICTrampoline(state());
}
TF_BUILTIN(StoreICStrict, CodeStubAssembler) {
AccessorAssembler::GenerateStoreIC(state());
}
TF_BUILTIN(StoreICStrictTrampoline, CodeStubAssembler) {
AccessorAssembler::GenerateStoreICTrampoline(state());
}
TF_BUILTIN(KeyedStoreIC, CodeStubAssembler) {
AccessorAssembler::GenerateKeyedStoreICTF(state(), SLOPPY);
}
TF_BUILTIN(KeyedStoreICTrampoline, CodeStubAssembler) {
AccessorAssembler::GenerateKeyedStoreICTrampolineTF(state(), SLOPPY);
}
TF_BUILTIN(KeyedStoreICStrict, CodeStubAssembler) {
AccessorAssembler::GenerateKeyedStoreICTF(state(), STRICT);
}
TF_BUILTIN(KeyedStoreICStrictTrampoline, CodeStubAssembler) {
AccessorAssembler::GenerateKeyedStoreICTrampolineTF(state(), STRICT);
}
} // namespace internal
} // namespace v8

6
src/builtins/builtins-utils.h
View File

@ -121,13 +121,13 @@ class BuiltinArguments : public Arguments {
public: \
explicit Name##Assembler(compiler::CodeAssemblerState* state) \
: AssemblerBase(state) {} \
void Generate##Name(); \
void Generate##NameImpl(); \
}; \
void Builtins::Generate_##Name(compiler::CodeAssemblerState* state) { \
Name##Assembler assembler(state); \
assembler.Generate##Name(); \
assembler.Generate##NameImpl(); \
} \
void Name##Assembler::Generate##Name()
void Name##Assembler::Generate##NameImpl()
// ----------------------------------------------------------------------------

18
src/builtins/builtins.h
View File

@ -437,6 +437,24 @@ namespace internal {
CPP(JsonParse) \
CPP(JsonStringify) \
\
/* ICs */ \
TFS(LoadIC, LOAD_IC, kNoExtraICState, LoadWithVector) \
TFS(LoadICTrampoline, LOAD_IC, kNoExtraICState, Load) \
TFS(KeyedLoadIC, KEYED_LOAD_IC, kNoExtraICState, LoadWithVector) \
TFS(KeyedLoadICTrampoline, KEYED_LOAD_IC, kNoExtraICState, Load) \
TFS(StoreIC, STORE_IC, kNoExtraICState, StoreWithVector) \
TFS(StoreICTrampoline, STORE_IC, kNoExtraICState, Store) \
TFS(StoreICStrict, STORE_IC, StoreICState::kStrictModeState, \
StoreWithVector) \
TFS(StoreICStrictTrampoline, STORE_IC, StoreICState::kStrictModeState, \
Store) \
TFS(KeyedStoreIC, KEYED_STORE_IC, kNoExtraICState, StoreWithVector) \
TFS(KeyedStoreICTrampoline, KEYED_STORE_IC, kNoExtraICState, Store) \
TFS(KeyedStoreICStrict, KEYED_STORE_IC, StoreICState::kStrictModeState, \
StoreWithVector) \
TFS(KeyedStoreICStrictTrampoline, KEYED_STORE_IC, \
StoreICState::kStrictModeState, Store) \
\
/* Math */ \
/* ES6 section 20.2.2.1 Math.abs ( x ) */ \
TFJ(MathAbs, 1) \

39
src/code-factory.cc
View File

@ -29,8 +29,8 @@ Handle<Code> CodeFactory::RuntimeCEntry(Isolate* isolate, int result_size) {
// static
Callable CodeFactory::LoadIC(Isolate* isolate) {
LoadICTrampolineStub stub(isolate);
return make_callable(stub);
return Callable(isolate->builtins()->LoadICTrampoline(),
LoadDescriptor(isolate));
}
// static
@ -41,8 +41,8 @@ Callable CodeFactory::ApiGetter(Isolate* isolate) {
// static
Callable CodeFactory::LoadICInOptimizedCode(Isolate* isolate) {
LoadICStub stub(isolate);
return make_callable(stub);
return Callable(isolate->builtins()->LoadIC(),
LoadWithVectorDescriptor(isolate));
}
// static
@ -60,14 +60,14 @@ Callable CodeFactory::LoadGlobalICInOptimizedCode(Isolate* isolate,
// static
Callable CodeFactory::KeyedLoadIC(Isolate* isolate) {
KeyedLoadICTrampolineTFStub stub(isolate);
return make_callable(stub);
return Callable(isolate->builtins()->KeyedLoadICTrampoline(),
LoadDescriptor(isolate));
}
// static
Callable CodeFactory::KeyedLoadICInOptimizedCode(Isolate* isolate) {
KeyedLoadICTFStub stub(isolate);
return make_callable(stub);
return Callable(isolate->builtins()->KeyedLoadIC(),
LoadWithVectorDescriptor(isolate));
}
// static
@ -93,29 +93,36 @@ Callable CodeFactory::CallICInOptimizedCode(Isolate* isolate,
// static
Callable CodeFactory::StoreIC(Isolate* isolate, LanguageMode language_mode) {
StoreICTrampolineStub stub(isolate, StoreICState(language_mode));
return make_callable(stub);
return Callable(language_mode == STRICT
? isolate->builtins()->StoreICStrictTrampoline()
: isolate->builtins()->StoreICTrampoline(),
StoreDescriptor(isolate));
}
// static
Callable CodeFactory::StoreICInOptimizedCode(Isolate* isolate,
LanguageMode language_mode) {
StoreICStub stub(isolate, StoreICState(language_mode));
return make_callable(stub);
return Callable(language_mode == STRICT ? isolate->builtins()->StoreICStrict()
: isolate->builtins()->StoreIC(),
StoreWithVectorDescriptor(isolate));
}
// static
Callable CodeFactory::KeyedStoreIC(Isolate* isolate,
LanguageMode language_mode) {
KeyedStoreICTrampolineTFStub stub(isolate, StoreICState(language_mode));
return make_callable(stub);
return Callable(language_mode == STRICT
? isolate->builtins()->KeyedStoreICStrictTrampoline()
: isolate->builtins()->KeyedStoreICTrampoline(),
StoreDescriptor(isolate));
}
// static
Callable CodeFactory::KeyedStoreICInOptimizedCode(Isolate* isolate,
LanguageMode language_mode) {
KeyedStoreICTFStub stub(isolate, StoreICState(language_mode));
return make_callable(stub);
return Callable(language_mode == STRICT
? isolate->builtins()->KeyedStoreICStrict()
: isolate->builtins()->KeyedStoreIC(),
StoreWithVectorDescriptor(isolate));
}
// static

24
src/code-stubs.cc
View File

@ -440,20 +440,6 @@ Handle<Code> TurboFanCodeStub::GenerateCode() {
return compiler::CodeAssembler::GenerateCode(&state);
}
#define ACCESSOR_ASSEMBLER(Name) \
void Name##Stub::GenerateAssembly(CodeAssemblerState* state) const { \
AccessorAssembler::Generate##Name(state); \
}
ACCESSOR_ASSEMBLER(LoadIC)
ACCESSOR_ASSEMBLER(LoadICTrampoline)
ACCESSOR_ASSEMBLER(KeyedLoadICTF)
ACCESSOR_ASSEMBLER(KeyedLoadICTrampolineTF)
ACCESSOR_ASSEMBLER(StoreIC)
ACCESSOR_ASSEMBLER(StoreICTrampoline)
#undef ACCESSOR_ASSEMBLER
void LoadICProtoArrayStub::GenerateAssembly(CodeAssemblerState* state) const {
AccessorAssembler::GenerateLoadICProtoArray(
state, throw_reference_error_if_nonexistent());
@ -468,16 +454,6 @@ void LoadGlobalICTrampolineStub::GenerateAssembly(
AccessorAssembler::GenerateLoadGlobalICTrampoline(state, typeof_mode());
}
void KeyedStoreICTrampolineTFStub::GenerateAssembly(
CodeAssemblerState* state) const {
AccessorAssembler::GenerateKeyedStoreICTrampolineTF(state, language_mode());
}
void KeyedStoreICTFStub::GenerateAssembly(
compiler::CodeAssemblerState* state) const {
AccessorAssembler::GenerateKeyedStoreICTF(state, language_mode());
}
void ElementsTransitionAndStoreStub::GenerateAssembly(
compiler::CodeAssemblerState* state) const {
typedef CodeStubAssembler::Label Label;

119
src/code-stubs.h
View File

@ -103,13 +103,9 @@ class Node;
V(NumberToString) \
V(StringAdd) \
V(GetProperty) \
V(LoadIC) \
V(LoadICProtoArray) \
V(KeyedLoadICTF) \
V(StoreFastElement) \
V(StoreGlobal) \
V(StoreIC) \
V(KeyedStoreICTF) \
V(StoreInterceptor) \
V(LoadApiGetter) \
V(LoadIndexedInterceptor) \
@ -118,11 +114,7 @@ class Node;
/* These are only called from FGC and */ \
/* can be removed when we use ignition */ \
/* only */ \
V(LoadICTrampoline) \
V(LoadGlobalICTrampoline) \
V(KeyedLoadICTrampolineTF) \
V(StoreICTrampoline) \
V(KeyedStoreICTrampolineTF)
V(LoadGlobalICTrampoline)
// List of code stubs only used on ARM 32 bits platforms.
#if V8_TARGET_ARCH_ARM
@ -1640,17 +1632,6 @@ class StringCharAtGenerator {
DISALLOW_COPY_AND_ASSIGN(StringCharAtGenerator);
};
class LoadICTrampolineStub : public TurboFanCodeStub {
public:
explicit LoadICTrampolineStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
Code::Kind GetCodeKind() const override { return Code::LOAD_IC; }
DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
DEFINE_TURBOFAN_CODE_STUB(LoadICTrampoline, TurboFanCodeStub);
};
class LoadGlobalICTrampolineStub : public TurboFanCodeStub {
public:
explicit LoadGlobalICTrampolineStub(Isolate* isolate,
@ -1674,50 +1655,6 @@ class LoadGlobalICTrampolineStub : public TurboFanCodeStub {
DEFINE_TURBOFAN_CODE_STUB(LoadGlobalICTrampoline, TurboFanCodeStub);
};
class KeyedLoadICTrampolineTFStub : public LoadICTrampolineStub {
public:
explicit KeyedLoadICTrampolineTFStub(Isolate* isolate)
: LoadICTrampolineStub(isolate) {}
Code::Kind GetCodeKind() const override { return Code::KEYED_LOAD_IC; }
DEFINE_TURBOFAN_CODE_STUB(KeyedLoadICTrampolineTF, LoadICTrampolineStub);
};
class StoreICTrampolineStub : public TurboFanCodeStub {
public:
StoreICTrampolineStub(Isolate* isolate, const StoreICState& state)
: TurboFanCodeStub(isolate) {
minor_key_ = state.GetExtraICState();
}
Code::Kind GetCodeKind() const override { return Code::STORE_IC; }
ExtraICState GetExtraICState() const final {
return static_cast<ExtraICState>(minor_key_);
}
protected:
StoreICState state() const { return StoreICState(GetExtraICState()); }
DEFINE_CALL_INTERFACE_DESCRIPTOR(Store);
DEFINE_TURBOFAN_CODE_STUB(StoreICTrampoline, TurboFanCodeStub);
};
class KeyedStoreICTrampolineTFStub : public StoreICTrampolineStub {
public:
KeyedStoreICTrampolineTFStub(Isolate* isolate, const StoreICState& state)
: StoreICTrampolineStub(isolate, state) {}
Code::Kind GetCodeKind() const override { return Code::KEYED_STORE_IC; }
LanguageMode language_mode() const {
return StoreICState(GetExtraICState()).language_mode();
}
DEFINE_TURBOFAN_CODE_STUB(KeyedStoreICTrampolineTF, StoreICTrampolineStub);
};
class CallICTrampolineStub : public PlatformCodeStub {
public:
CallICTrampolineStub(Isolate* isolate, const CallICState& state)
@ -1740,16 +1677,6 @@ class CallICTrampolineStub : public PlatformCodeStub {
DEFINE_PLATFORM_CODE_STUB(CallICTrampoline, PlatformCodeStub);
};
class LoadICStub : public TurboFanCodeStub {
public:
explicit LoadICStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
Code::Kind GetCodeKind() const override { return Code::LOAD_IC; }
DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
DEFINE_TURBOFAN_CODE_STUB(LoadIC, TurboFanCodeStub);
};
class LoadICProtoArrayStub : public TurboFanCodeStub {
public:
explicit LoadICProtoArrayStub(Isolate* isolate,
@ -1796,50 +1723,6 @@ class LoadGlobalICStub : public TurboFanCodeStub {
DEFINE_TURBOFAN_CODE_STUB(LoadGlobalIC, TurboFanCodeStub);
};
class KeyedLoadICTFStub : public LoadICStub {
public:
explicit KeyedLoadICTFStub(Isolate* isolate) : LoadICStub(isolate) {}
Code::Kind GetCodeKind() const override { return Code::KEYED_LOAD_IC; }
DEFINE_TURBOFAN_CODE_STUB(KeyedLoadICTF, LoadICStub);
};
class StoreICStub : public TurboFanCodeStub {
public:
StoreICStub(Isolate* isolate, const StoreICState& state)
: TurboFanCodeStub(isolate) {
minor_key_ = state.GetExtraICState();
}
Code::Kind GetCodeKind() const override { return Code::STORE_IC; }
LanguageMode language_mode() const {
return StoreICState(GetExtraICState()).language_mode();
}
ExtraICState GetExtraICState() const final {
return static_cast<ExtraICState>(minor_key_);
}
DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreWithVector);
DEFINE_TURBOFAN_CODE_STUB(StoreIC, TurboFanCodeStub);
};
class KeyedStoreICTFStub : public StoreICStub {
public:
KeyedStoreICTFStub(Isolate* isolate, const StoreICState& state)
: StoreICStub(isolate, state) {}
Code::Kind GetCodeKind() const override { return Code::KEYED_STORE_IC; }
LanguageMode language_mode() const {
return StoreICState(GetExtraICState()).language_mode();
}
DEFINE_TURBOFAN_CODE_STUB(KeyedStoreICTF, StoreICStub);
};
class DoubleToIStub : public PlatformCodeStub {
public:
DoubleToIStub(Isolate* isolate, Register source, Register destination,

16
src/ic/accessor-assembler.cc
View File

@ -1614,7 +1614,7 @@ void AccessorAssemblerImpl::KeyedStoreIC(const StoreICParameters* p,
//////////////////// Public methods.
void AccessorAssemblerImpl::GenerateLoadIC() {
typedef LoadICStub::Descriptor Descriptor;
typedef LoadWithVectorDescriptor Descriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
Node* name = Parameter(Descriptor::kName);
@ -1627,7 +1627,7 @@ void AccessorAssemblerImpl::GenerateLoadIC() {
}
void AccessorAssemblerImpl::GenerateLoadICTrampoline() {
typedef LoadICTrampolineStub::Descriptor Descriptor;
typedef LoadDescriptor Descriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
Node* name = Parameter(Descriptor::kName);
@ -1694,7 +1694,7 @@ void AccessorAssemblerImpl::GenerateLoadGlobalICTrampoline(
}
void AccessorAssemblerImpl::GenerateKeyedLoadICTF() {
typedef KeyedLoadICTFStub::Descriptor Descriptor;
typedef LoadWithVectorDescriptor Descriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
Node* name = Parameter(Descriptor::kName);
@ -1707,7 +1707,7 @@ void AccessorAssemblerImpl::GenerateKeyedLoadICTF() {
}
void AccessorAssemblerImpl::GenerateKeyedLoadICTrampolineTF() {
typedef KeyedLoadICTrampolineTFStub::Descriptor Descriptor;
typedef LoadDescriptor Descriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
Node* name = Parameter(Descriptor::kName);
@ -1733,7 +1733,7 @@ void AccessorAssemblerImpl::GenerateKeyedLoadICMegamorphic() {
}
void AccessorAssemblerImpl::GenerateStoreIC() {
typedef StoreICStub::Descriptor Descriptor;
typedef StoreWithVectorDescriptor Descriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
Node* name = Parameter(Descriptor::kName);
@ -1747,7 +1747,7 @@ void AccessorAssemblerImpl::GenerateStoreIC() {
}
void AccessorAssemblerImpl::GenerateStoreICTrampoline() {
typedef StoreICTrampolineStub::Descriptor Descriptor;
typedef StoreDescriptor Descriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
Node* name = Parameter(Descriptor::kName);
@ -1761,7 +1761,7 @@ void AccessorAssemblerImpl::GenerateStoreICTrampoline() {
}
void AccessorAssemblerImpl::GenerateKeyedStoreICTF(LanguageMode language_mode) {
typedef KeyedStoreICTFStub::Descriptor Descriptor;
typedef StoreWithVectorDescriptor Descriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
Node* name = Parameter(Descriptor::kName);
@ -1776,7 +1776,7 @@ void AccessorAssemblerImpl::GenerateKeyedStoreICTF(LanguageMode language_mode) {
void AccessorAssemblerImpl::GenerateKeyedStoreICTrampolineTF(
LanguageMode language_mode) {
typedef KeyedStoreICTrampolineTFStub::Descriptor Descriptor;
typedef StoreDescriptor Descriptor;
Node* receiver = Parameter(Descriptor::kReceiver);
Node* name = Parameter(Descriptor::kName);

7
src/snapshot/code-serializer.cc
View File

@ -88,7 +88,12 @@ void CodeSerializer::SerializeObject(HeapObject* obj, HowToCode how_to_code,
#define IC_KIND_CASE(KIND) case Code::KIND:
IC_KIND_LIST(IC_KIND_CASE)
#undef IC_KIND_CASE
SerializeCodeStub(code_object, how_to_code, where_to_point);
if (code_object->builtin_index() == -1) {
SerializeCodeStub(code_object, how_to_code, where_to_point);
} else {
SerializeBuiltin(code_object->builtin_index(), how_to_code,
where_to_point);
}
return;
case Code::FUNCTION:
DCHECK(code_object->has_reloc_info_for_serialization());

1
src/v8.gyp
View File

@ -494,6 +494,7 @@
'builtins/builtins-generator.cc',
'builtins/builtins-global.cc',
'builtins/builtins-handler.cc',
'builtins/builtins-ic.cc',
'builtins/builtins-internal.cc',
'builtins/builtins-interpreter.cc',
'builtins/builtins-json.cc',

7
test/cctest/cctest.status
View File

@ -84,6 +84,13 @@
'test-func-name-inference/UpperCaseClass': [FAIL],
'test-func-name-inference/LowerCaseClass': [FAIL],
# Bug(5784). StubCache tests need to be redesigned, as a) they don't work
# in the new (ignition + turbofan) pipeline environment, and b) they are
# stymied by a move of code stubs into builtins.
'test-api/PrimaryStubCache': [SKIP],
'test-api/SecondaryStubCache': [SKIP],
'test-api/AccessCheckInIC': [SKIP],
# BUG(3742).
'test-mark-compact/MarkCompactCollector': [PASS, ['arch==arm', NO_VARIANTS]],

16
test/cctest/test-api.cc
View File

@ -22168,22 +22168,6 @@ void RecompileICStubs(i::Isolate* isolate) {
LoadGlobalICState(NOT_INSIDE_TYPEOF));
Recompile<LoadGlobalICTrampolineStub>(isolate,
LoadGlobalICState(INSIDE_TYPEOF));
Recompile<LoadICStub>(isolate);
Recompile<LoadICTrampolineStub>(isolate);
Recompile<KeyedLoadICTFStub>(isolate);
Recompile<KeyedLoadICTrampolineTFStub>(isolate);
Recompile<StoreICStub>(isolate, StoreICState(SLOPPY));
Recompile<StoreICTrampolineStub>(isolate, StoreICState(SLOPPY));
Recompile<StoreICStub>(isolate, StoreICState(STRICT));
Recompile<StoreICTrampolineStub>(isolate, StoreICState(STRICT));
Recompile<KeyedStoreICTFStub>(isolate, StoreICState(SLOPPY));
Recompile<KeyedStoreICTrampolineTFStub>(isolate, StoreICState(SLOPPY));
Recompile<KeyedStoreICTFStub>(isolate, StoreICState(STRICT));
Recompile<KeyedStoreICTrampolineTFStub>(isolate, StoreICState(STRICT));
}
} // namespace

8
test/cctest/test-code-stub-assembler.cc
View File

@ -1782,14 +1782,6 @@ TEST(CodeStubAssemblerGraphsCorrectness) {
Recompile<LoadGlobalICStub>(isolate, LoadGlobalICState(NOT_INSIDE_TYPEOF));
Recompile<LoadGlobalICTrampolineStub>(isolate,
LoadGlobalICState(NOT_INSIDE_TYPEOF));
Recompile<LoadICStub>(isolate);
Recompile<LoadICTrampolineStub>(isolate);
Recompile<KeyedLoadICTFStub>(isolate);
Recompile<KeyedLoadICTrampolineTFStub>(isolate);
Recompile<StoreICStub>(isolate, StoreICState(STRICT));
Recompile<StoreICTrampolineStub>(isolate, StoreICState(STRICT));
Recompile<KeyedStoreICTFStub>(isolate, StoreICState(STRICT));
Recompile<KeyedStoreICTrampolineTFStub>(isolate, StoreICState(STRICT));
}
v8_isolate->Dispose();
}