| // Copyright 2019 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. |
| |
| // Serializer tests don't make sense in lite mode, as it doesn't gather |
| // IC feedback. |
| #ifndef V8_LITE_MODE |
| |
| #include "test/cctest/compiler/serializer-tester.h" |
| |
| #include "src/api/api-inl.h" |
| #include "src/codegen/optimized-compilation-info.h" |
| #include "src/compiler/serializer-for-background-compilation.h" |
| #include "src/compiler/zone-stats.h" |
| #include "src/zone/zone.h" |
| |
| namespace v8 { |
| namespace internal { |
| namespace compiler { |
| |
| SerializerTester::SerializerTester(const char* source) |
| : canonical_(main_isolate()) { |
| // The tests only make sense in the context of concurrent compilation. |
| FLAG_concurrent_inlining = true; |
| // --local-heaps is enabled by default, but some bots disable it. |
| // Ensure that it is enabled here because we have reverse implication |
| // from --no-local-heaps to --no-concurrent-inlining. |
| if (!FLAG_local_heaps) FLAG_local_heaps = true; |
| // The tests don't make sense when optimizations are turned off. |
| FLAG_opt = true; |
| // We need the IC to feed it to the serializer. |
| FLAG_use_ic = true; |
| // We need manual control over when a given function is optimized. |
| FLAG_always_opt = false; |
| // We need allocation of executable memory for the compilation. |
| FLAG_jitless = false; |
| FLAG_allow_natives_syntax = true; |
| FlagList::EnforceFlagImplications(); |
| |
| std::string function_string = "(function() { "; |
| function_string += source; |
| function_string += " })();"; |
| Handle<JSFunction> function = Handle<JSFunction>::cast(v8::Utils::OpenHandle( |
| *v8::Local<v8::Function>::Cast(CompileRun(function_string.c_str())))); |
| uint32_t flags = i::OptimizedCompilationInfo::kInlining | |
| i::OptimizedCompilationInfo::kFunctionContextSpecializing | |
| i::OptimizedCompilationInfo::kLoopPeeling | |
| i::OptimizedCompilationInfo::kBailoutOnUninitialized | |
| i::OptimizedCompilationInfo::kAllocationFolding | |
| i::OptimizedCompilationInfo::kSplitting | |
| i::OptimizedCompilationInfo::kAnalyzeEnvironmentLiveness; |
| Optimize(function, main_zone(), main_isolate(), flags, &broker_); |
| // Update handle to the corresponding serialized Handle in the broker. |
| function = |
| broker_->FindCanonicalPersistentHandleForTesting<JSFunction>(*function); |
| function_ = JSFunctionRef(broker(), function); |
| } |
| |
| TEST(SerializeEmptyFunction) { |
| SerializerTester tester( |
| "function f() {}; %EnsureFeedbackVectorForFunction(f); return f;"); |
| JSFunctionRef function = tester.function(); |
| CHECK(tester.broker()->IsSerializedForCompilation( |
| function.shared(), function.feedback_vector())); |
| } |
| |
| // This helper function allows for testing whether an inlinee candidate |
| // was properly serialized. It expects that the top-level function (that is |
| // run through the SerializerTester) will return its inlinee candidate. |
| void CheckForSerializedInlinee(const char* source, int argc = 0, |
| Handle<Object> argv[] = {}) { |
| SerializerTester tester(source); |
| JSFunctionRef f = tester.function(); |
| CHECK(tester.broker()->IsSerializedForCompilation(f.shared(), |
| f.feedback_vector())); |
| |
| MaybeHandle<Object> g_obj = Execution::Call( |
| tester.isolate(), tester.function().object(), |
| tester.isolate()->factory()->undefined_value(), argc, argv); |
| Handle<Object> g; |
| CHECK(g_obj.ToHandle(&g)); |
| |
| CHECK_WITH_MSG( |
| g->IsJSFunction(), |
| "The return value of the outer function must be a function too"); |
| Handle<JSFunction> g_func = Handle<JSFunction>::cast(g); |
| |
| // Look up corresponding serialized Handles in the broker. |
| Handle<SharedFunctionInfo> sfi( |
| tester.broker() |
| ->FindCanonicalPersistentHandleForTesting<SharedFunctionInfo>( |
| g_func->shared())); |
| SharedFunctionInfoRef g_sfi(tester.broker(), sfi); |
| Handle<FeedbackVector> fv( |
| tester.broker()->FindCanonicalPersistentHandleForTesting<FeedbackVector>( |
| g_func->feedback_vector())); |
| FeedbackVectorRef g_fv(tester.broker(), fv); |
| CHECK(tester.broker()->IsSerializedForCompilation(g_sfi, g_fv)); |
| } |
| |
| TEST(SerializeInlinedClosure) { |
| CheckForSerializedInlinee( |
| "function f() {" |
| " function g(){ return g; }" |
| " %EnsureFeedbackVectorForFunction(g);" |
| " return g();" |
| "};" |
| "%EnsureFeedbackVectorForFunction(f);" |
| "f(); return f;"); |
| } |
| |
| TEST(SerializeInlinedFunction) { |
| CheckForSerializedInlinee( |
| "function g() {};" |
| "%EnsureFeedbackVectorForFunction(g);" |
| "function f() {" |
| " g(); return g;" |
| "};" |
| "%EnsureFeedbackVectorForFunction(f);" |
| "f(); return f;"); |
| } |
| |
| TEST(SerializeCallUndefinedReceiver) { |
| CheckForSerializedInlinee( |
| "function g(a,b,c) {};" |
| "%EnsureFeedbackVectorForFunction(g);" |
| "function f() {" |
| " g(1,2,3); return g;" |
| "};" |
| "%EnsureFeedbackVectorForFunction(f);" |
| "f(); return f;"); |
| } |
| |
| TEST(SerializeCallUndefinedReceiver2) { |
| CheckForSerializedInlinee( |
| "function g(a,b) {};" |
| "%EnsureFeedbackVectorForFunction(g);" |
| "function f() {" |
| " g(1,2); return g;" |
| "};" |
| "%EnsureFeedbackVectorForFunction(f);" |
| "f(); return f;"); |
| } |
| |
| TEST(SerializeCallProperty) { |
| CheckForSerializedInlinee( |
| "let obj = {" |
| " g: function g(a,b,c) {}" |
| "};" |
| "%EnsureFeedbackVectorForFunction(obj.g);" |
| "function f() {" |
| " obj.g(1,2,3); return obj.g;" |
| "};" |
| "%EnsureFeedbackVectorForFunction(f);" |
| "f(); return f;"); |
| } |
| |
| TEST(SerializeCallProperty2) { |
| CheckForSerializedInlinee( |
| "let obj = {" |
| " g: function g(a,b) {}" |
| "};" |
| "%EnsureFeedbackVectorForFunction(obj.g);" |
| "function f() {" |
| " obj.g(1,2); return obj.g;" |
| "};" |
| "%EnsureFeedbackVectorForFunction(f);" |
| "f(); return f;"); |
| } |
| |
| TEST(SerializeCallAnyReceiver) { |
| CheckForSerializedInlinee( |
| "let obj = {" |
| " g: function g() {}" |
| "};" |
| "%EnsureFeedbackVectorForFunction(obj.g);" |
| "function f() {" |
| " with(obj) {" |
| " g(); return g;" |
| " };" |
| "};" |
| "%EnsureFeedbackVectorForFunction(f);" |
| "f(); return f;"); |
| } |
| |
| TEST(SerializeCallWithSpread) { |
| CheckForSerializedInlinee( |
| "function g(args) {};" |
| "%EnsureFeedbackVectorForFunction(g);" |
| "const arr = [1,2,3];" |
| "function f() {" |
| " g(...arr); return g;" |
| "};" |
| "%EnsureFeedbackVectorForFunction(f);" |
| "f(); return f;"); |
| } |
| |
| // The following test causes the CallIC of `g` to turn megamorphic, |
| // thus allowing us to test if we forward arguments hints (`callee` in this |
| // example) and correctly serialize the inlining candidate `j`. |
| TEST(SerializeCallArguments) { |
| CheckForSerializedInlinee( |
| "function g(callee) { callee(); };" |
| "function h() {};" |
| "function i() {};" |
| "%EnsureFeedbackVectorForFunction(g);" |
| "g(h); g(i);" |
| "function f() {" |
| " function j() {};" |
| " g(j);" |
| " return j;" |
| "};" |
| "%EnsureFeedbackVectorForFunction(f);" |
| "var j = f();" |
| "%EnsureFeedbackVectorForFunction(j);" |
| "f(); return f;"); |
| } |
| |
| TEST(SerializeConstruct) { |
| CheckForSerializedInlinee( |
| "function g() {};" |
| "%EnsureFeedbackVectorForFunction(g);" |
| "function f() {" |
| " new g(); return g;" |
| "};" |
| "%EnsureFeedbackVectorForFunction(f);" |
| "f(); return f;"); |
| } |
| |
| TEST(SerializeConstructWithSpread) { |
| CheckForSerializedInlinee( |
| "function g(a, b, c) {};" |
| "%EnsureFeedbackVectorForFunction(g);" |
| "const arr = [1, 2];" |
| "function f() {" |
| " new g(0, ...arr); return g;" |
| "};" |
| "%EnsureFeedbackVectorForFunction(f);" |
| "f(); return f;"); |
| } |
| |
| TEST(SerializeConstructSuper) { |
| CheckForSerializedInlinee( |
| "class A {};" |
| "class B extends A { constructor() { super(); } };" |
| "%EnsureFeedbackVectorForFunction(A);" |
| "%EnsureFeedbackVectorForFunction(B);" |
| "function f() {" |
| " new B(); return A;" |
| "};" |
| "%EnsureFeedbackVectorForFunction(f);" |
| "f(); return f;"); |
| } |
| |
| TEST(SerializeConditionalJump) { |
| CheckForSerializedInlinee( |
| "function g(callee) { callee(); };" |
| "function h() {};" |
| "function i() {};" |
| "%EnsureFeedbackVectorForFunction(g);" |
| "let a = true;" |
| "g(h); g(i);" |
| "function f() {" |
| " function q() {};" |
| " if (a) g(q);" |
| " return q;" |
| "};" |
| "%EnsureFeedbackVectorForFunction(f);" |
| "var q = f();" |
| "%EnsureFeedbackVectorForFunction(q);" |
| "f(); return f;"); |
| } |
| |
| TEST(SerializeUnconditionalJump) { |
| CheckForSerializedInlinee( |
| "function g(callee) { callee(); };" |
| "function h() {};" |
| "function i() {};" |
| "%EnsureFeedbackVectorForFunction(g);" |
| "%EnsureFeedbackVectorForFunction(h);" |
| "%EnsureFeedbackVectorForFunction(i);" |
| "let a = false;" |
| "g(h); g(i);" |
| "function f() {" |
| " function p() {};" |
| " function q() {};" |
| " if (a) q();" |
| " else g(p);" |
| " return p;" |
| "};" |
| "%EnsureFeedbackVectorForFunction(f);" |
| "var p = f();" |
| "%EnsureFeedbackVectorForFunction(p);" |
| "f(); return f;"); |
| } |
| |
| TEST(MergeJumpTargetEnvironment) { |
| CheckForSerializedInlinee( |
| "function f() {" |
| " let g;" |
| " while (true) {" |
| " if (g === undefined) {g = ()=>1; break;} else {g = ()=>2; break};" |
| " };" |
| " g(); return g;" |
| "};" |
| "%EnsureFeedbackVectorForFunction(f);" |
| "%EnsureFeedbackVectorForFunction(f());" |
| "f(); return f;"); // Two calls to f to make g() megamorhpic. |
| } |
| |
| TEST(BoundFunctionTarget) { |
| CheckForSerializedInlinee( |
| "function apply(foo, arg) { return foo(arg); };" |
| "%EnsureFeedbackVectorForFunction(apply);" |
| "function test() {" |
| " const lambda = (a) => a;" |
| " %EnsureFeedbackVectorForFunction(lambda);" |
| " let bound = apply.bind(null, lambda).bind(null, 42);" |
| " %TurbofanStaticAssert(bound() == 42); return apply;" |
| "};" |
| "%EnsureFeedbackVectorForFunction(test);" |
| "test(); return test;"); |
| } |
| |
| TEST(BoundFunctionArguments) { |
| CheckForSerializedInlinee( |
| "function apply(foo, arg) { return foo(arg); };" |
| "%EnsureFeedbackVectorForFunction(apply);" |
| "function test() {" |
| " const lambda = (a) => a;" |
| " %EnsureFeedbackVectorForFunction(lambda);" |
| " let bound = apply.bind(null, lambda).bind(null, 42);" |
| " %TurbofanStaticAssert(bound() == 42); return lambda;" |
| "};" |
| "%EnsureFeedbackVectorForFunction(test);" |
| "test(); return test;"); |
| } |
| |
| TEST(ArrowFunctionInlined) { |
| // The loop is to ensure there is a feedback vector for the arrow function |
| // {b}. |
| CheckForSerializedInlinee( |
| "function foo() {" |
| " let b = x => x * x;" |
| " let a = [1, 2, 3].map(b);" |
| " return b;" |
| "}" |
| "%EnsureFeedbackVectorForFunction(foo);" |
| "for (let i = 0; i < 100; ++i) foo();" |
| "return foo;"); |
| } |
| |
| TEST(BoundFunctionResult) { |
| CheckForSerializedInlinee( |
| "function id(x) { return x }" |
| "function foo() { id.bind(undefined, 42)(); return id; }" |
| "%PrepareFunctionForOptimization(foo);" |
| "%PrepareFunctionForOptimization(id);" |
| "foo();" |
| "foo();" |
| "%OptimizeFunctionOnNextCall(foo);" |
| "foo(); return foo;"); |
| } |
| |
| TEST(MultipleFunctionCalls) { |
| CheckForSerializedInlinee( |
| "function inc(x) { return ++x; }" |
| "function dec(x) { return --x; }" |
| "function apply(f, x) { return f(x); }" |
| "function foo() { apply(inc, 42); apply(dec, 42); return dec; }" |
| "%PrepareFunctionForOptimization(inc);" |
| "%PrepareFunctionForOptimization(dec);" |
| "%PrepareFunctionForOptimization(apply);" |
| "%PrepareFunctionForOptimization(foo);" |
| "foo();" |
| "foo();" |
| "%OptimizeFunctionOnNextCall(foo);" |
| "foo(); return foo;"); |
| } |
| |
| } // namespace compiler |
| } // namespace internal |
| } // namespace v8 |
| |
| #endif // V8_LITE_MODE |
