Move HandleCache to HGraph.
This avoids passing the `VariableSizedHandleScope*` argument
around and eliminates HGraph::inexact_object_rti_ and its
initialization. The latter shall allow running Optimizing
gtests that do not require type information without creating
a Runtime in future. (To be implemented in a separate CL.)
Test: m test-art-host-gtest
Test: testrunner.py --host --optmizing
Test: aosp_taimen-userdebug boots.
Change-Id: I36fe9bc556c6d610d644c8c14cc74c9985a14d64
diff --git a/compiler/optimizing/inliner.cc b/compiler/optimizing/inliner.cc
index 5472839..5920f78 100644
--- a/compiler/optimizing/inliner.cc
+++ b/compiler/optimizing/inliner.cc
@@ -855,7 +855,8 @@
ClassLinker* class_linker = caller_compilation_unit_.GetClassLinker();
PointerSize pointer_size = class_linker->GetImagePointerSize();
- Handle<mirror::Class> monomorphic_type = handles_->NewHandle(GetMonomorphicType(classes));
+ Handle<mirror::Class> monomorphic_type =
+ graph_->GetHandleCache()->NewHandle(GetMonomorphicType(classes));
resolved_method = ResolveMethodFromInlineCache(
monomorphic_type, resolved_method, invoke_instruction, pointer_size);
@@ -891,7 +892,6 @@
ReferenceTypePropagation rtp_fixup(graph_,
outer_compilation_unit_.GetClassLoader(),
outer_compilation_unit_.GetDexCache(),
- handles_,
/* is_first_run= */ false);
rtp_fixup.Run();
@@ -1019,7 +1019,7 @@
}
ArtMethod* method = nullptr;
- Handle<mirror::Class> handle = handles_->NewHandle(classes->Get(i));
+ Handle<mirror::Class> handle = graph_->GetHandleCache()->NewHandle(classes->Get(i));
method = ResolveMethodFromInlineCache(
handle, resolved_method, invoke_instruction, pointer_size);
if (method == nullptr) {
@@ -1091,7 +1091,6 @@
ReferenceTypePropagation rtp_fixup(graph_,
outer_compilation_unit_.GetClassLoader(),
outer_compilation_unit_.GetDexCache(),
- handles_,
/* is_first_run= */ false);
rtp_fixup.Run();
return true;
@@ -1287,7 +1286,6 @@
ReferenceTypePropagation rtp_fixup(graph_,
outer_compilation_unit_.GetClassLoader(),
outer_compilation_unit_.GetDexCache(),
- handles_,
/* is_first_run= */ false);
rtp_fixup.Run();
@@ -1411,7 +1409,6 @@
ReferenceTypePropagation(graph_,
outer_compilation_unit_.GetClassLoader(),
outer_compilation_unit_.GetDexCache(),
- handles_,
/* is_first_run= */ false).Run();
}
return true;
@@ -1729,11 +1726,11 @@
/* dex_pc= */ 0);
if (iget->GetType() == DataType::Type::kReference) {
// Use the same dex_cache that we used for field lookup as the hint_dex_cache.
- Handle<mirror::DexCache> dex_cache = handles_->NewHandle(referrer->GetDexCache());
+ Handle<mirror::DexCache> dex_cache =
+ graph_->GetHandleCache()->NewHandle(referrer->GetDexCache());
ReferenceTypePropagation rtp(graph_,
outer_compilation_unit_.GetClassLoader(),
dex_cache,
- handles_,
/* is_first_run= */ false);
rtp.Visit(iget);
}
@@ -1772,11 +1769,9 @@
}
template <typename T>
-static inline Handle<T> NewHandleIfDifferent(ObjPtr<T> object,
- Handle<T> hint,
- VariableSizedHandleScope* handles)
+static inline Handle<T> NewHandleIfDifferent(ObjPtr<T> object, Handle<T> hint, HGraph* graph)
REQUIRES_SHARED(Locks::mutator_lock_) {
- return (object != hint.Get()) ? handles->NewHandle(object) : hint;
+ return (object != hint.Get()) ? graph->GetHandleCache()->NewHandle(object) : hint;
}
static bool CanEncodeInlinedMethodInStackMap(const DexFile& caller_dex_file, ArtMethod* callee)
@@ -1839,7 +1834,6 @@
ReferenceTypePropagation(callee_graph,
outer_compilation_unit_.GetClassLoader(),
dex_compilation_unit.GetDexCache(),
- handles_,
/* is_first_run= */ false).Run();
}
}
@@ -1997,13 +1991,14 @@
ClassLinker* class_linker = caller_compilation_unit_.GetClassLinker();
Handle<mirror::DexCache> dex_cache = NewHandleIfDifferent(resolved_method->GetDexCache(),
caller_compilation_unit_.GetDexCache(),
- handles_);
+ graph_);
Handle<mirror::ClassLoader> class_loader =
NewHandleIfDifferent(resolved_method->GetDeclaringClass()->GetClassLoader(),
caller_compilation_unit_.GetClassLoader(),
- handles_);
+ graph_);
- Handle<mirror::Class> compiling_class = handles_->NewHandle(resolved_method->GetDeclaringClass());
+ Handle<mirror::Class> compiling_class =
+ graph_->GetHandleCache()->NewHandle(resolved_method->GetDeclaringClass());
DexCompilationUnit dex_compilation_unit(
class_loader,
class_linker,
@@ -2035,6 +2030,7 @@
HGraph* callee_graph = new (graph_->GetAllocator()) HGraph(
graph_->GetAllocator(),
graph_->GetArenaStack(),
+ graph_->GetHandleCache()->GetHandles(),
callee_dex_file,
method_index,
codegen_->GetCompilerOptions().GetInstructionSet(),
@@ -2066,8 +2062,7 @@
&outer_compilation_unit_,
codegen_,
inline_stats_,
- resolved_method->GetQuickenedInfo(),
- handles_);
+ resolved_method->GetQuickenedInfo());
if (builder.BuildGraph() != kAnalysisSuccess) {
LOG_FAIL(stats_, MethodCompilationStat::kNotInlinedCannotBuild)
@@ -2158,7 +2153,6 @@
codegen_,
outer_compilation_unit_,
dex_compilation_unit,
- handles_,
inline_stats_,
total_number_of_dex_registers_ + accessor.RegistersSize(),
total_number_of_instructions_ + number_of_instructions,
@@ -2267,7 +2261,7 @@
DCHECK(return_replacement->IsPhi());
ObjPtr<mirror::Class> cls = resolved_method->LookupResolvedReturnType();
ReferenceTypeInfo rti = ReferenceTypePropagation::IsAdmissible(cls)
- ? ReferenceTypeInfo::Create(handles_->NewHandle(cls))
+ ? ReferenceTypeInfo::Create(graph_->GetHandleCache()->NewHandle(cls))
: graph_->GetInexactObjectRti();
return_replacement->SetReferenceTypeInfo(rti);
}