From 175edfb4701a63f3e4470363bd8b5d47f91488dc Mon Sep 17 00:00:00 2001 From: bmeurer Date: Fri, 25 Sep 2015 04:33:28 -0700 Subject: [PATCH] [turbofan] Rename --context-specialization to --function-context-specialization. This name makes it clear that the flag (also the variant in the Compiler) is talking about specializing to the function context instead of i.e. the native context. R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/1372513003 Cr-Commit-Position: refs/heads/master@{#30934} --- src/compiler.cc | 12 ++++++------ src/compiler.h | 10 +++++++--- src/compiler/pipeline.cc | 7 ++++--- src/flag-definitions.h | 4 ++-- test/cctest/compiler/function-tester.h | 10 +++++----- test/cctest/compiler/test-run-inlining.cc | 5 +++-- test/cctest/compiler/test-run-properties.cc | 12 ++++++------ test/cctest/test-serialize.cc | 2 +- test/mjsunit/regress/regress-4374.js | 2 +- test/mjsunit/regress/regress-osr-context.js | 3 ++- 10 files changed, 37 insertions(+), 30 deletions(-) diff --git a/src/compiler.cc b/src/compiler.cc index 1af7cb9..4085a71 100644 --- a/src/compiler.cc +++ b/src/compiler.cc @@ -130,7 +130,7 @@ CompilationInfo::CompilationInfo(ParseInfo* parse_info) // with deoptimization support. if (isolate_->serializer_enabled()) EnableDeoptimizationSupport(); - if (FLAG_context_specialization) MarkAsContextSpecializing(); + if (FLAG_function_context_specialization) MarkAsFunctionContextSpecializing(); if (FLAG_turbo_inlining) MarkAsInliningEnabled(); if (FLAG_turbo_source_positions) MarkAsSourcePositionsEnabled(); if (FLAG_turbo_splitting) MarkAsSplittingEnabled(); @@ -440,7 +440,7 @@ OptimizedCompileJob::Status OptimizedCompileJob::CreateGraph() { if (info()->shared_info()->asm_function()) { if (info()->osr_frame()) info()->MarkAsFrameSpecializing(); - info()->MarkAsContextSpecializing(); + info()->MarkAsFunctionContextSpecializing(); } else if (FLAG_turbo_type_feedback) { info()->MarkAsTypeFeedbackEnabled(); info()->EnsureFeedbackVector(); @@ -777,8 +777,8 @@ static void InsertCodeIntoOptimizedCodeMap(CompilationInfo* info) { if (code->kind() != Code::OPTIMIZED_FUNCTION) return; // Nothing to do. // Context specialization folds-in the context, so no sharing can occur. - if (info->is_context_specializing()) return; - // Frame specialization implies context specialization. + if (info->is_function_context_specializing()) return; + // Frame specialization implies function context specialization. DCHECK(!info->is_frame_specializing()); // Do not cache bound functions. @@ -799,7 +799,7 @@ static void InsertCodeIntoOptimizedCodeMap(CompilationInfo* info) { // Cache optimized context-independent code. if (FLAG_turbo_cache_shared_code && code->is_turbofanned()) { - DCHECK(!info->is_context_specializing()); + DCHECK(!info->is_function_context_specializing()); DCHECK(info->osr_ast_id().IsNone()); Handle shared(function->shared()); SharedFunctionInfo::AddSharedCodeToOptimizedCodeMap(shared, code); @@ -975,7 +975,7 @@ MaybeHandle Compiler::GetStubCode(Handle function, ParseInfo parse_info(&zone, function); CompilationInfo info(&parse_info); info.SetFunctionType(stub->GetCallInterfaceDescriptor().GetFunctionType()); - info.MarkAsContextSpecializing(); + info.MarkAsFunctionContextSpecializing(); info.MarkAsDeoptimizationEnabled(); info.SetStub(stub); diff --git a/src/compiler.h b/src/compiler.h index 5c5bb02..45cf7b5 100644 --- a/src/compiler.h +++ b/src/compiler.h @@ -121,7 +121,7 @@ class CompilationInfo { kDeoptimizationSupport = 1 << 5, kDebug = 1 << 6, kSerializing = 1 << 7, - kContextSpecializing = 1 << 8, + kFunctionContextSpecializing = 1 << 8, kFrameSpecializing = 1 << 9, kInliningEnabled = 1 << 10, kTypingEnabled = 1 << 11, @@ -221,9 +221,13 @@ class CompilationInfo { bool will_serialize() const { return GetFlag(kSerializing); } - void MarkAsContextSpecializing() { SetFlag(kContextSpecializing); } + void MarkAsFunctionContextSpecializing() { + SetFlag(kFunctionContextSpecializing); + } - bool is_context_specializing() const { return GetFlag(kContextSpecializing); } + bool is_function_context_specializing() const { + return GetFlag(kFunctionContextSpecializing); + } void MarkAsFrameSpecializing() { SetFlag(kFrameSpecializing); } diff --git a/src/compiler/pipeline.cc b/src/compiler/pipeline.cc index fd79a86..209ddfd 100644 --- a/src/compiler/pipeline.cc +++ b/src/compiler/pipeline.cc @@ -504,9 +504,10 @@ struct InliningPhase { CommonOperatorReducer common_reducer(&graph_reducer, data->graph(), data->common(), data->machine()); JSContextSpecialization context_specialization( - &graph_reducer, data->jsgraph(), data->info()->is_context_specializing() - ? data->info()->context() - : MaybeHandle()); + &graph_reducer, data->jsgraph(), + data->info()->is_function_context_specializing() + ? data->info()->context() + : MaybeHandle()); JSFrameSpecialization frame_specialization(data->info()->osr_frame(), data->jsgraph()); JSInliner inliner(&graph_reducer, data->info()->is_inlining_enabled() diff --git a/src/flag-definitions.h b/src/flag-definitions.h index df22b0b..8578820 100644 --- a/src/flag-definitions.h +++ b/src/flag-definitions.h @@ -431,8 +431,8 @@ DEFINE_BOOL(turbo_allocate, false, "enable inline allocations in TurboFan") DEFINE_BOOL(turbo_source_positions, false, "track source code positions when building TurboFan IR") DEFINE_IMPLICATION(trace_turbo, turbo_source_positions) -DEFINE_BOOL(context_specialization, false, - "enable context specialization in TurboFan") +DEFINE_BOOL(function_context_specialization, false, + "enable function context specialization in TurboFan") DEFINE_BOOL(turbo_inlining, false, "enable inlining in TurboFan") DEFINE_BOOL(trace_turbo_inlining, false, "trace TurboFan inlining") DEFINE_BOOL(loop_assignment_analysis, true, "perform loop assignment analysis") diff --git a/test/cctest/compiler/function-tester.h b/test/cctest/compiler/function-tester.h index f16463e..c2b25e5 100644 --- a/test/cctest/compiler/function-tester.h +++ b/test/cctest/compiler/function-tester.h @@ -31,9 +31,9 @@ class FunctionTester : public InitializedHandleScope { function((FLAG_allow_natives_syntax = true, NewFunction(source))), flags_(flags) { Compile(function); - const uint32_t supported_flags = CompilationInfo::kContextSpecializing | - CompilationInfo::kInliningEnabled | - CompilationInfo::kTypingEnabled; + const uint32_t supported_flags = + CompilationInfo::kFunctionContextSpecializing | + CompilationInfo::kInliningEnabled | CompilationInfo::kTypingEnabled; CHECK_EQ(0u, flags_ & ~supported_flags); } @@ -161,8 +161,8 @@ class FunctionTester : public InitializedHandleScope { CHECK(Parser::ParseStatic(info.parse_info())); info.SetOptimizing(BailoutId::None(), Handle(function->code())); - if (flags_ & CompilationInfo::kContextSpecializing) { - info.MarkAsContextSpecializing(); + if (flags_ & CompilationInfo::kFunctionContextSpecializing) { + info.MarkAsFunctionContextSpecializing(); } if (flags_ & CompilationInfo::kInliningEnabled) { info.MarkAsInliningEnabled(); diff --git a/test/cctest/compiler/test-run-inlining.cc b/test/cctest/compiler/test-run-inlining.cc index 8aa9d03..05fb6ad 100644 --- a/test/cctest/compiler/test-run-inlining.cc +++ b/test/cctest/compiler/test-run-inlining.cc @@ -43,10 +43,11 @@ void InstallAssertInlineCountHelper(v8::Isolate* isolate) { const uint32_t kRestrictedInliningFlags = - CompilationInfo::kContextSpecializing | CompilationInfo::kTypingEnabled; + CompilationInfo::kFunctionContextSpecializing | + CompilationInfo::kTypingEnabled; const uint32_t kInlineFlags = CompilationInfo::kInliningEnabled | - CompilationInfo::kContextSpecializing | + CompilationInfo::kFunctionContextSpecializing | CompilationInfo::kTypingEnabled; } // namespace diff --git a/test/cctest/compiler/test-run-properties.cc b/test/cctest/compiler/test-run-properties.cc index b7677f7..f2d72e4 100644 --- a/test/cctest/compiler/test-run-properties.cc +++ b/test/cctest/compiler/test-run-properties.cc @@ -41,9 +41,9 @@ static void TypedArrayLoadHelper(const char* array_type) { values_buffer.start(), array_type, arraysize(kValues), values_buffer.start(), array_type, array_type); - FunctionTester T( - source_buffer.start(), - CompilationInfo::kContextSpecializing | CompilationInfo::kTypingEnabled); + FunctionTester T(source_buffer.start(), + CompilationInfo::kFunctionContextSpecializing | + CompilationInfo::kTypingEnabled); for (size_t i = 0; i < arraysize(kValues); ++i) { for (size_t j = 0; j < arraysize(kValues); ++j) { volatile U value_a = static_cast(kValues[i]); @@ -109,9 +109,9 @@ static void TypedArrayStoreHelper(const char* array_type) { values_buffer.start(), array_type, arraysize(kValues), values_buffer.start(), array_type, array_type); - FunctionTester T( - source_buffer.start(), - CompilationInfo::kContextSpecializing | CompilationInfo::kTypingEnabled); + FunctionTester T(source_buffer.start(), + CompilationInfo::kFunctionContextSpecializing | + CompilationInfo::kTypingEnabled); for (size_t i = 0; i < arraysize(kValues); ++i) { for (size_t j = 0; j < arraysize(kValues); ++j) { volatile U value_a = static_cast(kValues[i]); diff --git a/test/cctest/test-serialize.cc b/test/cctest/test-serialize.cc index bf36081..a37d6a0 100644 --- a/test/cctest/test-serialize.cc +++ b/test/cctest/test-serialize.cc @@ -1599,7 +1599,7 @@ TEST(SerializeInternalReference) { return; #endif // Disable experimental natives that are loaded after deserialization. - FLAG_context_specialization = false; + FLAG_function_context_specialization = false; FLAG_always_opt = true; const char* flag = "--turbo-filter=foo"; FlagList::SetFlagsFromString(flag, StrLength(flag)); diff --git a/test/mjsunit/regress/regress-4374.js b/test/mjsunit/regress/regress-4374.js index bbdcfb9..afae71c 100644 --- a/test/mjsunit/regress/regress-4374.js +++ b/test/mjsunit/regress/regress-4374.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --allow-natives-syntax --context-specialization +// Flags: --allow-natives-syntax --function-context-specialization // Flags: --turbo-filter=f --turbo-inlining var f = (function() { diff --git a/test/mjsunit/regress/regress-osr-context.js b/test/mjsunit/regress/regress-osr-context.js index 8ceb791..a739541 100644 --- a/test/mjsunit/regress/regress-osr-context.js +++ b/test/mjsunit/regress/regress-osr-context.js @@ -2,7 +2,8 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --allow-natives-syntax --context-specialization --turbo-filter=f +// Flags: --allow-natives-syntax --function-context-specialization +// Flags: --turbo-filter=f (function() { "use strict"; -- 2.7.4