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

Revert of [Interpreter] Add CreateClosure to BytecodeGraphBuilder. (patchset #8 id:140001 of https://codereview.chromium.org/1458603012/ )

Browse Source 
Reason for revert:
Build break.

Original issue's description:
> [Interpreter] Add CreateClosure to BytecodeGraphBuilder.
>
> Adds code and tests to support CreateClosure bytecode when building
> graphs.
>
> BUG=v8:4280
> LOG=N
>
> Committed: https://crrev.com/4cceb11b0929abcbc82bf0854554a9b66003335d
> Cr-Commit-Position: refs/heads/master@{#32224}

TBR=bmeurer@chromium.org,mythria@chromium.org,mstarzinger@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=v8:4280

Review URL: https://codereview.chromium.org/1471913004

Cr-Commit-Position: refs/heads/master@{#32225}
This commit is contained in:
oth 2015-11-24 10:10:46 -08:00 committed by Commit bot
parent 4cceb11b09
commit daf185b243
12 changed files with 92 additions and 262 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/compiler/bytecode-graph-builder.cc
View File

@ -643,20 +643,7 @@ void BytecodeGraphBuilder::VisitPopContext(
void BytecodeGraphBuilder::VisitCreateClosure(
const interpreter::BytecodeArrayIterator& iterator) {
Handle<SharedFunctionInfo> shared_info =
Handle<SharedFunctionInfo>::cast(iterator.GetConstantForIndexOperand(0));
PretenureFlag tenured =
iterator.GetImmediateOperand(1) ? TENURED : NOT_TENURED;
const Operator* op = javascript()->CreateClosure(shared_info, tenured);
Node* closure = NewNode(op);
AddEmptyFrameStateInputs(closure);
environment()->BindAccumulator(closure);
}
void BytecodeGraphBuilder::VisitCreateClosureWide(
const interpreter::BytecodeArrayIterator& iterator) {
VisitCreateClosure(iterator);
UNIMPLEMENTED();
}

13
src/interpreter/bytecode-array-builder.cc
View File

@ -444,18 +444,9 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::StoreKeyedProperty(
BytecodeArrayBuilder& BytecodeArrayBuilder::CreateClosure(
Handle<SharedFunctionInfo> shared_info, PretenureFlag tenured) {
size_t entry = GetConstantPoolEntry(shared_info);
PretenureFlag tenured) {
DCHECK(FitsInImm8Operand(tenured));
if (FitsInIdx8Operand(entry)) {
Output(Bytecode::kCreateClosure, static_cast<uint8_t>(entry),
static_cast<uint8_t>(tenured));
} else if (FitsInIdx16Operand(entry)) {
Output(Bytecode::kCreateClosureWide, static_cast<uint16_t>(entry),
static_cast<uint8_t>(tenured));
} else {
UNIMPLEMENTED();
}
Output(Bytecode::kCreateClosure, static_cast<uint8_t>(tenured));
return *this;
}

5
src/interpreter/bytecode-array-builder.h
View File

@ -116,9 +116,8 @@ class BytecodeArrayBuilder {
int feedback_slot,
LanguageMode language_mode);
// Create a new closure for the SharedFunctionInfo.
BytecodeArrayBuilder& CreateClosure(Handle<SharedFunctionInfo> shared_info,
PretenureFlag tenured);
// Create a new closure for the SharedFunctionInfo in the accumulator.
BytecodeArrayBuilder& CreateClosure(PretenureFlag tenured);
// Create a new arguments object in the accumulator.
BytecodeArrayBuilder& CreateArguments(CreateArgumentsType type);

6
src/interpreter/bytecode-generator.cc
View File

@ -971,8 +971,10 @@ void BytecodeGenerator::VisitFunctionLiteral(FunctionLiteral* expr) {
Handle<SharedFunctionInfo> shared_info =
Compiler::GetSharedFunctionInfo(expr, info()->script(), info());
CHECK(!shared_info.is_null()); // TODO(rmcilroy): Set stack overflow?
builder()->CreateClosure(shared_info,
expr->pretenure() ? TENURED : NOT_TENURED);
builder()
->LoadLiteral(shared_info)
.CreateClosure(expr->pretenure() ? TENURED : NOT_TENURED);
execution_result()->SetResultInAccumulator();
}

3
src/interpreter/bytecodes.h
View File

@ -161,8 +161,7 @@ namespace interpreter {
V(CreateObjectLiteral, OperandType::kIdx8, OperandType::kImm8) \
\
/* Closure allocation */ \
V(CreateClosure, OperandType::kIdx8, OperandType::kImm8) \
V(CreateClosureWide, OperandType::kIdx16, OperandType::kImm8) \
V(CreateClosure, OperandType::kImm8) \
\
/* Arguments allocation */ \
V(CreateMappedArguments, OperandType::kNone) \

21
src/interpreter/interpreter.cc
View File

@ -1367,16 +1367,15 @@ void Interpreter::DoCreateObjectLiteral(
}
// CreateClosure <index> <tenured>
// CreateClosure <tenured>
//
// Creates a new closure for SharedFunctionInfo at position |index| in the
// constant pool and with the PretenureFlag <tenured>.
// Creates a new closure for SharedFunctionInfo in the accumulator with the
// PretenureFlag <tenured>.
void Interpreter::DoCreateClosure(compiler::InterpreterAssembler* assembler) {
// TODO(rmcilroy): Possibly call FastNewClosureStub when possible instead of
// calling into the runtime.
Node* index = __ BytecodeOperandIdx(0);
Node* shared = __ LoadConstantPoolEntry(index);
Node* tenured_raw = __ BytecodeOperandImm(1);
Node* shared = __ GetAccumulator();
Node* tenured_raw = __ BytecodeOperandImm(0);
Node* tenured = __ SmiTag(tenured_raw);
Node* result =
__ CallRuntime(Runtime::kInterpreterNewClosure, shared, tenured);
@ -1385,16 +1384,6 @@ void Interpreter::DoCreateClosure(compiler::InterpreterAssembler* assembler) {
}
// CreateClosureWide <index> <tenured>
//
// Creates a new closure for SharedFunctionInfo at position |index| in the
// constant pool and with the PretenureFlag <tenured>.
void Interpreter::DoCreateClosureWide(
compiler::InterpreterAssembler* assembler) {
return DoCreateClosure(assembler);
}
// CreateMappedArguments
//
// Creates a new mapped arguments object.

39
test/cctest/compiler/test-run-bytecode-graph-builder.cc
View File

@ -575,45 +575,6 @@ TEST(BytecodeGraphBuilderCallNew) {
}
TEST(BytecodeGraphBuilderCreateClosure) {
HandleAndZoneScope scope;
Isolate* isolate = scope.main_isolate();
Zone* zone = scope.main_zone();
Factory* factory = isolate->factory();
ExpectedSnippet<0> snippets[] = {
{"function f() {\n"
" function counter() { this.count = 20; }\n"
" var c = new counter();\n"
" return c.count;\n"
"}; f()",
{factory->NewNumberFromInt(20)}},
{"function f() {\n"
" function counter(arg0) { this.count = 17; this.x = arg0; }\n"
" var c = new counter(6);\n"
" return c.count + c.x;\n"
"}; f()",
{factory->NewNumberFromInt(23)}},
{"function f() {\n"
" function counter(arg0, arg1) {\n"
" this.count = 17; this.x = arg0; this.y = arg1;\n"
" }\n"
" var c = new counter(3, 5);\n"
" return c.count + c.x + c.y;\n"
"}; f()",
{factory->NewNumberFromInt(25)}},
};
size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
for (size_t i = 0; i < num_snippets; i++) {
BytecodeGraphTester tester(isolate, zone, snippets[i].code_snippet);
auto callable = tester.GetCallable<>();
Handle<Object> return_value = callable().ToHandleChecked();
CHECK(return_value->SameValue(*snippets[i].return_value()));
}
}
TEST(BytecodeGraphBuilderCallRuntime) {
HandleAndZoneScope scope;
Isolate* isolate = scope.main_isolate();

123
test/cctest/interpreter/test-bytecode-generator.cc
View File

@ -2665,7 +2665,7 @@ TEST(Delete) {
"return delete a[1];",
2 * kPointerSize,
1,
28,
29,
{
B(CallRuntime), U16(Runtime::kNewFunctionContext), //
R(closure), U8(1), //
@ -2673,7 +2673,8 @@ TEST(Delete) {
B(LdaConstant), U8(0), //
B(CreateObjectLiteral), U8(0), U8(deep_elements_flags), //
B(StaContextSlot), R(0), U8(first_context_slot), //
B(CreateClosure), U8(1), U8(0), //
B(LdaConstant), U8(1), //
B(CreateClosure), U8(0), //
B(LdaContextSlot), R(0), U8(first_context_slot), //
B(Star), R(1), //
B(LdaSmi8), U8(1), //
@ -2794,21 +2795,23 @@ TEST(FunctionLiterals) {
{"return function(){ }",
0,
1,
4,
5,
{
B(CreateClosure), U8(0), U8(0), //
B(Return) //
B(LdaConstant), U8(0), //
B(CreateClosure), U8(0), //
B(Return) //
},
1,
{InstanceType::SHARED_FUNCTION_INFO_TYPE}},
{"return (function(){ })()",
2 * kPointerSize,
1,
14,
15,
{
B(LdaUndefined), //
B(Star), R(1), //
B(CreateClosure), U8(0), U8(0), //
B(LdaConstant), U8(0), //
B(CreateClosure), U8(0), //
B(Star), R(0), //
B(Call), R(0), R(1), U8(0), U8(vector->GetIndex(slot)), //
B(Return) //
@ -2818,11 +2821,12 @@ TEST(FunctionLiterals) {
{"return (function(x){ return x; })(1)",
3 * kPointerSize,
1,
18,
19,
{
B(LdaUndefined), //
B(Star), R(1), //
B(CreateClosure), U8(0), U8(0), //
B(LdaConstant), U8(0), //
B(CreateClosure), U8(0), //
B(Star), R(0), //
B(LdaSmi8), U8(1), //
B(Star), R(2), //
@ -3100,12 +3104,13 @@ TEST(ObjectLiterals) {
{"return { func: function() { } };",
1 * kPointerSize,
1,
17,
18,
{
B(LdaConstant), U8(0), //
B(CreateObjectLiteral), U8(0), U8(deep_elements_flags), //
B(Star), R(0), //
B(CreateClosure), U8(2), U8(0), //
B(LdaConstant), U8(2), //
B(CreateClosure), U8(0), //
B(StoreICSloppy), R(0), U8(1), U8(vector->GetIndex(slot1)), //
B(Ldar), R(0), //
B(Return), //
@ -3117,12 +3122,13 @@ TEST(ObjectLiterals) {
{"return { func(a) { return a; } };",
1 * kPointerSize,
1,
17,
18,
{
B(LdaConstant), U8(0), //
B(CreateObjectLiteral), U8(0), U8(deep_elements_flags), //
B(Star), R(0), //
B(CreateClosure), U8(2), U8(0), //
B(LdaConstant), U8(2), //
B(CreateClosure), U8(0), //
B(StoreICSloppy), R(0), U8(1), U8(vector->GetIndex(slot1)), //
B(Ldar), R(0), //
B(Return), //
@ -3134,14 +3140,15 @@ TEST(ObjectLiterals) {
{"return { get a() { return 2; } };",
5 * kPointerSize,
1,
30,
31,
{
B(LdaConstant), U8(0), //
B(CreateObjectLiteral), U8(0), U8(deep_elements_flags), //
B(Star), R(0), //
B(LdaConstant), U8(1), //
B(Star), R(1), //
B(CreateClosure), U8(2), U8(0), //
B(LdaConstant), U8(2), //
B(CreateClosure), U8(0), //
B(Star), R(2), //
B(LdaNull), //
B(Star), R(3), //
@ -3159,16 +3166,18 @@ TEST(ObjectLiterals) {
{"return { get a() { return this.x; }, set a(val) { this.x = val } };",
5 * kPointerSize,
1,
32,
34,
{
B(LdaConstant), U8(0), //
B(CreateObjectLiteral), U8(0), U8(deep_elements_flags), //
B(Star), R(0), //
B(LdaConstant), U8(1), //
B(Star), R(1), //
B(CreateClosure), U8(2), U8(0), //
B(LdaConstant), U8(2), //
B(CreateClosure), U8(0), //
B(Star), R(2), //
B(CreateClosure), U8(3), U8(0), //
B(LdaConstant), U8(3), //
B(CreateClosure), U8(0), //
B(Star), R(3), //
B(LdaZero), //
B(Star), R(4), //
@ -3185,7 +3194,7 @@ TEST(ObjectLiterals) {
{"return { set b(val) { this.y = val } };",
5 * kPointerSize,
1,
30,
31,
{
B(LdaConstant), U8(0), //
B(CreateObjectLiteral), U8(0), U8(deep_elements_flags), //
@ -3194,7 +3203,8 @@ TEST(ObjectLiterals) {
B(Star), R(1), //
B(LdaNull), //
B(Star), R(2), //
B(CreateClosure), U8(2), U8(0), //
B(LdaConstant), U8(2), //
B(CreateClosure), U8(0), //
B(Star), R(3), //
B(LdaZero), //
B(Star), R(4), //
@ -3329,7 +3339,7 @@ TEST(ObjectLiterals) {
{"var n = 'name'; return { [n]: 'val', get a() { }, set a(b) {} };",
5 * kPointerSize,
1,
67,
69,
{
B(LdaConstant), U8(0), //
B(Star), R(0), //
@ -3348,7 +3358,8 @@ TEST(ObjectLiterals) {
B(LdaConstant), U8(3), //
B(ToName), //
B(Star), R(2), //
B(CreateClosure), U8(4), U8(0), //
B(LdaConstant), U8(4), //
B(CreateClosure), U8(0), //
B(Star), R(3), //
B(LdaZero), //
B(Star), R(4), //
@ -3357,7 +3368,8 @@ TEST(ObjectLiterals) {
B(LdaConstant), U8(3), //
B(ToName), //
B(Star), R(2), //
B(CreateClosure), U8(5), U8(0), //
B(LdaConstant), U8(5), //
B(CreateClosure), U8(0), //
B(Star), R(3), //
B(LdaZero), //
B(Star), R(4), //
@ -3394,7 +3406,7 @@ TEST(TopLevelObjectLiterals) {
{"var a = { func: function() { } };",
5 * kPointerSize,
1,
49,
50,
{
B(LdaConstant), U8(0), //
B(Star), R(1), //
@ -3408,7 +3420,8 @@ TEST(TopLevelObjectLiterals) {
B(LdaConstant), U8(2), //
B(CreateObjectLiteral), U8(0), U8(has_function_flags), //
B(Star), R(4), //
B(CreateClosure), U8(4), U8(1), //
B(LdaConstant), U8(4), //
B(CreateClosure), U8(1), //
B(StoreICSloppy), R(4), U8(3), U8(5), //
B(CallRuntime), U16(Runtime::kToFastProperties), R(4), U8(1), //
B(Ldar), R(4), //
@ -3650,12 +3663,13 @@ TEST(ContextVariables) {
{"var a; return function() { a = 1; };",
1 * kPointerSize,
1,
11,
12,
{
B(CallRuntime), U16(Runtime::kNewFunctionContext), //
R(closure), U8(1), //
B(PushContext), R(0), //
B(CreateClosure), U8(0), U8(0), //
B(LdaConstant), U8(0), //
B(CreateClosure), U8(0), //
B(Return), //
},
1,
@ -3663,14 +3677,15 @@ TEST(ContextVariables) {
{"var a = 1; return function() { a = 2; };",
1 * kPointerSize,
1,
16,
17,
{
B(CallRuntime), U16(Runtime::kNewFunctionContext), //
R(closure), U8(1), //
B(PushContext), R(0), //
B(LdaSmi8), U8(1), //
B(StaContextSlot), R(0), U8(first_context_slot), //
B(CreateClosure), U8(0), U8(0), //
B(LdaConstant), U8(0), //
B(CreateClosure), U8(0), //
B(Return), //
},
1,
@ -3678,7 +3693,7 @@ TEST(ContextVariables) {
{"var a = 1; var b = 2; return function() { a = 2; b = 3 };",
1 * kPointerSize,
1,
21,
22,
{
B(CallRuntime), U16(Runtime::kNewFunctionContext), //
R(closure), U8(1), //
@ -3687,7 +3702,8 @@ TEST(ContextVariables) {
B(StaContextSlot), R(0), U8(first_context_slot), //
B(LdaSmi8), U8(2), //
B(StaContextSlot), R(0), U8(first_context_slot + 1), //
B(CreateClosure), U8(0), U8(0), //
B(LdaConstant), U8(0), //
B(CreateClosure), U8(0), //
B(Return), //
},
1,
@ -3695,14 +3711,15 @@ TEST(ContextVariables) {
{"var a; (function() { a = 2; })(); return a;",
3 * kPointerSize,
1,
24,
25,
{
B(CallRuntime), U16(Runtime::kNewFunctionContext), //
R(closure), U8(1), //
B(PushContext), R(0), //
B(LdaUndefined), //
B(Star), R(2), //
B(CreateClosure), U8(0), U8(0), //
B(LdaConstant), U8(0), //
B(CreateClosure), U8(0), //
B(Star), R(1), //
B(Call), R(1), R(2), U8(0), U8(vector->GetIndex(slot)), //
B(LdaContextSlot), R(0), U8(first_context_slot), //
@ -3713,7 +3730,7 @@ TEST(ContextVariables) {
{"'use strict'; let a = 1; { let b = 2; return function() { a + b; }; }",
4 * kPointerSize,
1,
44,
45,
{
B(CallRuntime), U16(Runtime::kNewFunctionContext), //
R(closure), U8(1), //
@ -3732,7 +3749,8 @@ TEST(ContextVariables) {
B(StaContextSlot), R(1), U8(first_context_slot), //
B(LdaSmi8), U8(2), //
B(StaContextSlot), R(1), U8(first_context_slot), //
B(CreateClosure), U8(1), U8(0), //
B(LdaConstant), U8(1), //
B(CreateClosure), U8(0), //
B(Return), //
},
2,
@ -3759,14 +3777,15 @@ TEST(ContextParameters) {
{"function f(arg1) { return function() { arg1 = 2; }; }",
1 * kPointerSize,
2,
16,
17,
{
B(CallRuntime), U16(Runtime::kNewFunctionContext), //
R(closure), U8(1), //
B(PushContext), R(0), //
B(Ldar), R(helper.kLastParamIndex), //
B(StaContextSlot), R(0), U8(first_context_slot), //
B(CreateClosure), U8(0), U8(0), //
B(LdaConstant), U8(0), //
B(CreateClosure), U8(0), //
B(Return), //
},
1,
@ -3774,14 +3793,15 @@ TEST(ContextParameters) {
{"function f(arg1) { var a = function() { arg1 = 2; }; return arg1; }",
2 * kPointerSize,
2,
21,
22,
{
B(CallRuntime), U16(Runtime::kNewFunctionContext), //
R(closure), U8(1), //
B(PushContext), R(1), //
B(Ldar), R(helper.kLastParamIndex), //
B(StaContextSlot), R(1), U8(first_context_slot), //
B(CreateClosure), U8(0), U8(0), //
B(LdaConstant), U8(0), //
B(CreateClosure), U8(0), //
B(Star), R(0), //
B(LdaContextSlot), R(1), U8(first_context_slot), //
B(Return), //
@ -3791,7 +3811,7 @@ TEST(ContextParameters) {
{"function f(a1, a2, a3, a4) { return function() { a1 = a3; }; }",
1 * kPointerSize,
5,
21,
22,
{
B(CallRuntime), U16(Runtime::kNewFunctionContext), //
R(closure), U8(1), //
@ -3800,7 +3820,8 @@ TEST(ContextParameters) {
B(StaContextSlot), R(0), U8(first_context_slot + 1), //
B(Ldar), R(helper.kLastParamIndex -1), //
B(StaContextSlot), R(0), U8(first_context_slot), //
B(CreateClosure), U8(0), U8(0), //
B(LdaConstant), U8(0), //
B(CreateClosure), U8(0), //
B(Return), //
},
1,
@ -3808,14 +3829,15 @@ TEST(ContextParameters) {
{"function f() { var self = this; return function() { self = 2; }; }",
1 * kPointerSize,
1,
16,
17,
{
B(CallRuntime), U16(Runtime::kNewFunctionContext), //
R(closure), U8(1), //
B(PushContext), R(0), //
B(Ldar), R(helper.kLastParamIndex), //
B(StaContextSlot), R(0), U8(first_context_slot), //
B(CreateClosure), U8(0), U8(0), //
B(LdaConstant), U8(0), //
B(CreateClosure), U8(0), //
B(Return), //
},
1,
@ -4053,14 +4075,15 @@ TEST(CountOperators) {
{"var a = 1; var b = function() { return a }; return ++a;",
2 * kPointerSize,
1,
26,
27,
{
B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), //
U8(1), //
B(PushContext), R(1), //
B(LdaSmi8), U8(1), //
B(StaContextSlot), R(1), U8(first_context_slot), //
B(CreateClosure), U8(0), U8(0), //
B(LdaConstant), U8(0), //
B(CreateClosure), U8(0), //
B(Star), R(0), //
B(LdaContextSlot), R(1), U8(first_context_slot), //
B(ToNumber), //
@ -4073,14 +4096,15 @@ TEST(CountOperators) {
{"var a = 1; var b = function() { return a }; return a--;",
3 * kPointerSize,
1,
30,
31,
{
B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), //
U8(1), //
B(PushContext), R(1), //
B(LdaSmi8), U8(1), //
B(StaContextSlot), R(1), U8(first_context_slot), //
B(CreateClosure), U8(0), U8(0), //
B(LdaConstant), U8(0), //
B(CreateClosure), U8(0), //
B(Star), R(0), //
B(LdaContextSlot), R(1), U8(first_context_slot), //
B(ToNumber), //
@ -4290,14 +4314,15 @@ TEST(CompoundExpressions) {
{"var a = 1; (function f() { return a; }); a |= 24;",
2 * kPointerSize,
1,
29,
30,
{
B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), //
U8(1), //
B(PushContext), R(0), //
B(LdaSmi8), U8(1), //
B(StaContextSlot), R(0), U8(first_context_slot), //
B(CreateClosure), U8(0), U8(0), //
B(LdaConstant), U8(0), //
B(CreateClosure), U8(0), //
B(LdaContextSlot), R(0), U8(first_context_slot), //
B(Star), R(1), //
B(LdaSmi8), U8(24), //

54
test/unittests/compiler/bytecode-graph-builder-unittest.cc
View File

@ -40,12 +40,6 @@ class BytecodeGraphBuilderTest : public TestWithIsolateAndZone {
public:
BytecodeGraphBuilderTest() {}
std::pair<Graph*, Handle<SharedFunctionInfo>> GetCompletedGraphAndSharedInfo(
Handle<BytecodeArray> bytecode_array,
MaybeHandle<TypeFeedbackVector> feedback_vector =
MaybeHandle<TypeFeedbackVector>(),
LanguageMode language_mode = LanguageMode::SLOPPY);
Graph* GetCompletedGraph(Handle<BytecodeArray> bytecode_array,
MaybeHandle<TypeFeedbackVector> feedback_vector =
MaybeHandle<TypeFeedbackVector>(),
@ -69,8 +63,7 @@ class BytecodeGraphBuilderTest : public TestWithIsolateAndZone {
};
std::pair<Graph*, Handle<SharedFunctionInfo>>
BytecodeGraphBuilderTest::GetCompletedGraphAndSharedInfo(
Graph* BytecodeGraphBuilderTest::GetCompletedGraph(
Handle<BytecodeArray> bytecode_array,
MaybeHandle<TypeFeedbackVector> feedback_vector,
LanguageMode language_mode) {
@ -98,17 +91,7 @@ BytecodeGraphBuilderTest::GetCompletedGraphAndSharedInfo(
BytecodeGraphBuilder graph_builder(zone(), &info, jsgraph);
graph_builder.CreateGraph();
return std::make_pair(graph_builder.graph(), shared_info);
}
Graph* BytecodeGraphBuilderTest::GetCompletedGraph(
Handle<BytecodeArray> bytecode_array,
MaybeHandle<TypeFeedbackVector> feedback_vector,
LanguageMode language_mode) {
return GetCompletedGraphAndSharedInfo(bytecode_array, feedback_vector,
language_mode)
.first;
return graph;
}
@ -824,39 +807,6 @@ TEST_F(BytecodeGraphBuilderTest, New) {
EXPECT_THAT(ret, IsReturn(call_construct, call_construct, IsIfSuccess(_)));
}
TEST_F(BytecodeGraphBuilderTest, CreateClosure) {
PretenureFlag kPretenureFlags[] = {NOT_TENURED, TENURED};
TRACED_FOREACH(PretenureFlag, pretenure_flag, kPretenureFlags) {
interpreter::BytecodeArrayBuilder inner_builder(isolate(), zone());
inner_builder.set_locals_count(0);
inner_builder.set_context_count(0);
inner_builder.set_parameter_count(3);
inner_builder.LoadAccumulatorWithRegister(inner_builder.Parameter(2))
.BinaryOperation(Token::Value::ADD, inner_builder.Parameter(1),
Strength::WEAK)
.Return();
std::pair<Graph*, Handle<SharedFunctionInfo>> inner_graph_and_shared_info =
GetCompletedGraphAndSharedInfo(inner_builder.ToBytecodeArray());
Handle<SharedFunctionInfo> shared_info = inner_graph_and_shared_info.second;
interpreter::BytecodeArrayBuilder builder(isolate(), zone());
builder.set_locals_count(4);
builder.set_context_count(0);
builder.set_parameter_count(3);
builder.CreateClosure(shared_info, pretenure_flag).Return();
Graph* graph = GetCompletedGraph(builder.ToBytecodeArray());
Node* start = graph->start();
Node* ret = graph->end()->InputAt(0);
Matcher<Node*> create_closure =
IsCreateClosure(shared_info, pretenure_flag, start, start);
EXPECT_THAT(ret, IsReturn(create_closure, create_closure, start));
}
}
} // namespace compiler
} // namespace internal
} // namespace v8

60
test/unittests/compiler/node-test-utils.cc
View File

@ -27,7 +27,6 @@ bool operator==(Handle<HeapObject> const& lhs, Handle<HeapObject> const& rhs) {
return lhs.is_identical_to(rhs);
}
namespace compiler {
namespace {
@ -1859,56 +1858,6 @@ class IsJSCallMatcher final : public NodeMatcher {
const Matcher<Node*> control_matcher_;
};
class IsCreateClosureMatcher final : public NodeMatcher {
public:
IsCreateClosureMatcher(
const Matcher<Handle<SharedFunctionInfo>>& shared_info_matcher,
const Matcher<PretenureFlag>& pretenure_matcher,
const Matcher<Node*>& effect_matcher,
const Matcher<Node*>& control_matcher)
: NodeMatcher(IrOpcode::Value::kJSCreateClosure),
shared_info_matcher_(shared_info_matcher),
pretenure_matcher_(pretenure_matcher),
effect_matcher_(effect_matcher),
control_matcher_(control_matcher) {}
void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose value (";
shared_info_matcher_.DescribeTo(os);
*os << ",";
pretenure_matcher_.DescribeTo(os);
*os << "), effect (";
effect_matcher_.DescribeTo(os);
*os << ") and control (";
control_matcher_.DescribeTo(os);
*os << ")";
}
bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
if (!NodeMatcher::MatchAndExplain(node, listener)) {
return false;
}
return (PrintMatchAndExplain(
OpParameter<const CreateClosureParameters>(node).shared_info(),
"value", shared_info_matcher_, listener) &&
PrintMatchAndExplain(
OpParameter<CreateClosureParameters>(node).pretenure(), "value",
pretenure_matcher_, listener) &&
PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
effect_matcher_, listener) &&
PrintMatchAndExplain(NodeProperties::GetControlInput(node),
"control", control_matcher_, listener));
}
private:
const Matcher<Handle<SharedFunctionInfo>> shared_info_matcher_;
const Matcher<PretenureFlag> pretenure_matcher_;
const Matcher<Node*> effect_matcher_;
const Matcher<Node*> control_matcher_;
};
} // namespace
@ -2586,15 +2535,6 @@ Matcher<Node*> IsJSCallRuntime(std::vector<Matcher<Node*>> value_matchers,
}
Matcher<Node*> IsCreateClosure(const Handle<SharedFunctionInfo> shared_info,
PretenureFlag pretenure,
const Matcher<Node*>& effect_matcher,
const Matcher<Node*>& control_matcher) {
return MakeMatcher(new IsCreateClosureMatcher(
shared_info, pretenure, effect_matcher, control_matcher));
}
#define IS_BINOP_MATCHER(Name) \
Matcher<Node*> Is##Name(const Matcher<Node*>& lhs_matcher, \
const Matcher<Node*>& rhs_matcher) { \

5
test/unittests/compiler/node-test-utils.h
View File

@ -17,7 +17,6 @@ class ExternalReference;
template <typename T>
class Handle;
class HeapObject;
class SharedFunctionInfo;
template <class>
class TypeImpl;
enum TypeofMode : int;
@ -406,10 +405,6 @@ Matcher<Node*> IsJSDeleteProperty(const Matcher<Node*>& object_value_matcher,
const Matcher<Node*>& key_matcher,
const Matcher<Node*>& effect_matcher,
const Matcher<Node*>& control_matcher);
Matcher<Node*> IsCreateClosure(const Handle<SharedFunctionInfo> shared_info,
PretenureFlag pretenure,
const Matcher<Node*>& effect_matcher,
const Matcher<Node*>& control_matcher);
} // namespace compiler
} // namespace internal

10
test/unittests/interpreter/bytecode-array-builder-unittest.cc
View File

@ -94,10 +94,7 @@ TEST_F(BytecodeArrayBuilderTest, AllBytecodesGenerated) {
.StoreKeyedProperty(reg, reg, 2056, LanguageMode::STRICT);
// Emit closure operations.
Factory* factory = isolate()->factory();
Handle<SharedFunctionInfo> shared_info = factory->NewSharedFunctionInfo(
factory->NewStringFromStaticChars("function_a"), MaybeHandle<Code>());
builder.CreateClosure(shared_info, NOT_TENURED);
builder.CreateClosure(NOT_TENURED);
// Emit argument creation operations.
builder.CreateArguments(CreateArgumentsType::kMappedArguments)
@ -218,11 +215,6 @@ TEST_F(BytecodeArrayBuilderTest, AllBytecodesGenerated) {
}
builder.LoadLiteral(Smi::FromInt(20000000));
// CreateClosureWide
Handle<SharedFunctionInfo> shared_info2 = factory->NewSharedFunctionInfo(
factory->NewStringFromStaticChars("function_b"), MaybeHandle<Code>());
builder.CreateClosure(shared_info2, NOT_TENURED);
builder.Return();
// Generate BytecodeArray.