From 3507105caea0d209c66a95d5ec5d739949105c5d Mon Sep 17 00:00:00 2001 From: Nicolas Geoffray Date: Tue, 9 Jun 2015 15:43:38 +0100 Subject: [PATCH] Add support for inlining already sharpened interface calls. Change-Id: Ia6b557c5e98e493b187b1f30da0c62449d9dd4d4 --- compiler/optimizing/inliner.cc | 26 +++++------ compiler/optimizing/inliner.h | 2 +- .../expected.txt | 5 +++ test/492-checker-inline-invoke-interface/info.txt | 1 + .../src/Main.java | 50 ++++++++++++++++++++++ 5 files changed, 71 insertions(+), 13 deletions(-) create mode 100644 test/492-checker-inline-invoke-interface/expected.txt create mode 100644 test/492-checker-inline-invoke-interface/info.txt create mode 100644 test/492-checker-inline-invoke-interface/src/Main.java diff --git a/compiler/optimizing/inliner.cc b/compiler/optimizing/inliner.cc index 5c73fd869..c3fc33735 100644 --- a/compiler/optimizing/inliner.cc +++ b/compiler/optimizing/inliner.cc @@ -62,7 +62,7 @@ void HInliner::Run() { if (call != nullptr && call->GetIntrinsic() == Intrinsics::kNone) { // We use the original invoke type to ensure the resolution of the called method // works properly. - if (!TryInline(call, call->GetDexMethodIndex(), call->GetOriginalInvokeType())) { + if (!TryInline(call, call->GetDexMethodIndex())) { if (kIsDebugBuild) { std::string callee_name = PrettyMethod(call->GetDexMethodIndex(), *outer_compilation_unit_.GetDexFile()); @@ -83,22 +83,18 @@ void HInliner::Run() { } } -bool HInliner::TryInline(HInvoke* invoke_instruction, - uint32_t method_index, - InvokeType invoke_type) const { +bool HInliner::TryInline(HInvoke* invoke_instruction, uint32_t method_index) const { ScopedObjectAccess soa(Thread::Current()); const DexFile& caller_dex_file = *caller_compilation_unit_.GetDexFile(); VLOG(compiler) << "Try inlining " << PrettyMethod(method_index, caller_dex_file); - StackHandleScope<3> hs(soa.Self()); - Handle dex_cache( - hs.NewHandle(caller_compilation_unit_.GetClassLinker()->FindDexCache(caller_dex_file))); - Handle class_loader(hs.NewHandle( - soa.Decode(caller_compilation_unit_.GetClassLoader()))); - ArtMethod* resolved_method(compiler_driver_->ResolveMethod( - soa, dex_cache, class_loader, &caller_compilation_unit_, method_index, invoke_type)); + ClassLinker* class_linker = caller_compilation_unit_.GetClassLinker(); + // We can query the dex cache directly. The verifier has populated it already. + ArtMethod* resolved_method = class_linker->FindDexCache(caller_dex_file)->GetResolvedMethod( + method_index, class_linker->GetImagePointerSize()); if (resolved_method == nullptr) { + // Method cannot be resolved if it is in another dex file we do not have access to. VLOG(compiler) << "Method cannot be resolved " << PrettyMethod(method_index, caller_dex_file); return false; } @@ -200,13 +196,19 @@ bool HInliner::TryBuildAndInline(ArtMethod* resolved_method, } } + InvokeType invoke_type = invoke_instruction->GetOriginalInvokeType(); + if (invoke_type == kInterface) { + // We have statically resolved the dispatch. To please the class linker + // at runtime, we change this call as if it was a virtual call. + invoke_type = kVirtual; + } HGraph* callee_graph = new (graph_->GetArena()) HGraph( graph_->GetArena(), caller_dex_file, method_index, requires_ctor_barrier, compiler_driver_->GetInstructionSet(), - invoke_instruction->GetOriginalInvokeType(), + invoke_type, graph_->IsDebuggable(), graph_->GetCurrentInstructionId()); diff --git a/compiler/optimizing/inliner.h b/compiler/optimizing/inliner.h index b86c1ed50..f7d8cf871 100644 --- a/compiler/optimizing/inliner.h +++ b/compiler/optimizing/inliner.h @@ -47,7 +47,7 @@ class HInliner : public HOptimization { static constexpr const char* kInlinerPassName = "inliner"; private: - bool TryInline(HInvoke* invoke_instruction, uint32_t method_index, InvokeType invoke_type) const; + bool TryInline(HInvoke* invoke_instruction, uint32_t method_index) const; bool TryBuildAndInline(ArtMethod* resolved_method, HInvoke* invoke_instruction, uint32_t method_index, diff --git a/test/492-checker-inline-invoke-interface/expected.txt b/test/492-checker-inline-invoke-interface/expected.txt new file mode 100644 index 000000000..b0014d752 --- /dev/null +++ b/test/492-checker-inline-invoke-interface/expected.txt @@ -0,0 +1,5 @@ +Hello from clinit +java.lang.Exception + at ForceStatic.(Main.java:24) + at Main.$inline$foo(Main.java:31) + at Main.main(Main.java:48) diff --git a/test/492-checker-inline-invoke-interface/info.txt b/test/492-checker-inline-invoke-interface/info.txt new file mode 100644 index 000000000..4a0a5ff1d --- /dev/null +++ b/test/492-checker-inline-invoke-interface/info.txt @@ -0,0 +1 @@ +Checker test to ensure we can inline interface calls. diff --git a/test/492-checker-inline-invoke-interface/src/Main.java b/test/492-checker-inline-invoke-interface/src/Main.java new file mode 100644 index 000000000..9a4548542 --- /dev/null +++ b/test/492-checker-inline-invoke-interface/src/Main.java @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2015 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +interface Itf { + public void $inline$foo(); +} + +class ForceStatic { + static { + System.out.println("Hello from clinit"); + new Exception().printStackTrace(); + } + static int field; +} + +public class Main implements Itf { + public void $inline$foo() { + int a = ForceStatic.field; + } + + /// CHECK-START: void Main.main(java.lang.String[]) inliner (before) + /// CHECK: InvokeStaticOrDirect + /// CHECK: InvokeStaticOrDirect + + /// CHECK-START: void Main.main(java.lang.String[]) inliner (before) + /// CHECK-NOT: ClinitCheck + + /// CHECK-START: void Main.main(java.lang.String[]) inliner (after) + /// CHECK-NOT: InvokeStaticOrDirect + + /// CHECK-START: void Main.main(java.lang.String[]) inliner (after) + /// CHECK: ClinitCheck + public static void main(String[] args) { + Itf itf = new Main(); + itf.$inline$foo(); + } +} -- 2.11.0