/*
* 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.
*/
#include "load_store_elimination.h"
#include "base/array_ref.h"
#include "base/scoped_arena_allocator.h"
#include "base/scoped_arena_containers.h"
#include "escape.h"
#include "load_store_analysis.h"
#include "side_effects_analysis.h"
#include <iostream>
/**
* The general algorithm of load-store elimination (LSE).
* Load-store analysis in the previous pass collects a list of heap locations
* and does alias analysis of those heap locations.
* LSE keeps track of a list of heap values corresponding to the heap
* locations. It visits basic blocks in reverse post order and for
* each basic block, visits instructions sequentially, and processes
* instructions as follows:
* - If the instruction is a load, and the heap location for that load has a
* valid heap value, the load can be eliminated. In order to maintain the
* validity of all heap locations during the optimization phase, the real
* elimination is delayed till the end of LSE.
* - If the instruction is a store, it updates the heap value for the heap
* location of the store with the store instruction. The real heap value
* can be fetched from the store instruction. Heap values are invalidated
* for heap locations that may alias with the store instruction's heap
* location. The store instruction can be eliminated unless the value stored
* is later needed e.g. by a load from the same/aliased heap location or
* the heap location persists at method return/deoptimization.
* The store instruction is also needed if it's not used to track the heap
* value anymore, e.g. when it fails to merge with the heap values from other
* predecessors.
* - A store that stores the same value as the heap value is eliminated.
* - The list of heap values are merged at basic block entry from the basic
* block's predecessors. The algorithm is single-pass, so loop side-effects is
* used as best effort to decide if a heap location is stored inside the loop.
* - A special type of objects called singletons are instantiated in the method
* and have a single name, i.e. no aliases. Singletons have exclusive heap
* locations since they have no aliases. Singletons are helpful in narrowing
* down the life span of a heap location such that they do not always
* need to participate in merging heap values. Allocation of a singleton
* can be eliminated if that singleton is not used and does not persist
* at method return/deoptimization.
* - For newly instantiated instances, their heap values are initialized to
* language defined default values.
* - Some instructions such as invokes are treated as loading and invalidating
* all the heap values, depending on the instruction's side effects.
* - Finalizable objects are considered as persisting at method
* return/deoptimization.
* - Currently this LSE algorithm doesn't handle SIMD graph, e.g. with VecLoad
* and VecStore instructions.
* - Currently this LSE algorithm doesn't handle graph with try-catch, due to
* the special block merging structure.
*/
namespace art {
// An unknown heap value. Loads with such a value in the heap location cannot be eliminated.
// A heap location can be set to kUnknownHeapValue when:
// - initially set a value.
// - killed due to aliasing, merging, invocation, or loop side effects.
static HInstruction* const kUnknownHeapValue =
reinterpret_cast<HInstruction*>(static_cast<uintptr_t>(-1));
// Default heap value after an allocation.
// A heap location can be set to that value right after an allocation.
static HInstruction* const kDefaultHeapValue =
reinterpret_cast<HInstruction*>(static_cast<uintptr_t>(-2));
// Use HGraphDelegateVisitor for which all VisitInvokeXXX() delegate to VisitInvoke().
class LSEVisitor : public HGraphDelegateVisitor {
public:
LSEVisitor(HGraph* graph,
const HeapLocationCollector& heap_locations_collector,
const SideEffectsAnalysis& side_effects,
OptimizingCompilerStats* stats)
: HGraphDelegateVisitor(graph, stats),
heap_location_collector_(heap_locations_collector),
side_effects_(side_effects),
allocator_(graph->GetArenaStack()),
heap_values_for_(graph->GetBlocks().size(),
ScopedArenaVector<HInstruction*>(heap_locations_collector.
GetNumberOfHeapLocations(),
kUnknownHeapValue,
allocator_.Adapter(kArenaAllocLSE)),
allocator_.Adapter(kArenaAllocLSE)),
removed_loads_(allocator_.Adapter(kArenaAllocLSE)),
substitute_instructions_for_loads_(allocator_.Adapter(kArenaAllocLSE)),
possibly_removed_stores_(allocator_.Adapter(kArenaAllocLSE)),
singleton_new_instances_(allocator_.Adapter(kArenaAllocLSE)) {
}
void VisitBasicBlock(HBasicBlock* block) override {
// Populate the heap_values array for this block.
// TODO: try to reuse the heap_values array from one predecessor if possible.
if (block->IsLoopHeader()) {
HandleLoopSideEffects(block);
} else {
MergePredecessorValues(block);
}
HGraphVisitor::VisitBasicBlock(block);
}
HTypeConversion* AddTypeConversionIfNecessary(HInstruction* instruction,
HInstruction* value,
DataType::Type expected_type) {
HTypeConversion* type_conversion = nullptr;
// Should never add type conversion into boolean value.
if (expected_type != DataType::Type::kBool &&
!DataType::IsTypeConversionImplicit(value->GetType(), expected_type)) {
type_conversion = new (GetGraph()->GetAllocator()) HTypeConversion(
expected_type, value, instruction->GetDexPc());
instruction->GetBlock()->InsertInstructionBefore(type_conversion, instruction);
}
return type_conversion;
}
// Find an instruction's substitute if it's a removed load.
// Return the same instruction if it should not be removed.
HInstruction* FindSubstitute(HInstruction* instruction) {
if (!IsLoad(instruction)) {
return instruction;
}
size_t size = removed_loads_.size();
for (size_t i = 0; i < size; i++) {
if (removed_loads_[i] == instruction) {
HInstruction* substitute = substitute_instructions_for_loads_[i];
// The substitute list is a flat hierarchy.
DCHECK_EQ(FindSubstitute(substitute), substitute);
return substitute;
}
}
return instruction;
}
void AddRemovedLoad(HInstruction* load, HInstruction* heap_value) {
DCHECK(IsLoad(load));
DCHECK_EQ(FindSubstitute(heap_value), heap_value) <<
"Unexpected heap_value that has a substitute " << heap_value->DebugName();
removed_loads_.push_back(load);
substitute_instructions_for_loads_.push_back(heap_value);
}
// Scan the list of removed loads to see if we can reuse `type_conversion`, if
// the other removed load has the same substitute and type and is dominated
// by `type_conversion`.
void TryToReuseTypeConversion(HInstruction* type_conversion, size_t index) {
size_t size = removed_loads_.size();
HInstruction* load = removed_loads_[index];
HInstruction* substitute = substitute_instructions_for_loads_[index];
for (size_t j = index + 1; j < size; j++) {
HInstruction* load2 = removed_loads_[j];
HInstruction* substitute2 = substitute_instructions_for_loads_[j];
if (load2 == nullptr) {
DCHECK(substitute2->IsTypeConversion());
continue;
}
DCHECK(load2->IsInstanceFieldGet() ||
load2->IsStaticFieldGet() ||
load2->IsArrayGet());
DCHECK(substitute2 != nullptr);
if (substitute2 == substitute &&
load2->GetType() == load->GetType() &&
type_conversion->GetBlock()->Dominates(load2->GetBlock()) &&
// Don't share across irreducible loop headers.
// TODO: can be more fine-grained than this by testing each dominator.
(load2->GetBlock() == type_conversion->GetBlock() ||
!GetGraph()->HasIrreducibleLoops())) {
// The removed_loads_ are added in reverse post order.
DCHECK(type_conversion->StrictlyDominates(load2));
load2->ReplaceWith(type_conversion);
load2->GetBlock()->RemoveInstruction(load2);
removed_loads_[j] = nullptr;
substitute_instructions_for_loads_[j] = type_conversion;
}
}
}
// Remove recorded instructions that should be eliminated.
void RemoveInstructions() {
size_t size = removed_loads_.size();
DCHECK_EQ(size, substitute_instructions_for_loads_.size());
for (size_t i = 0; i < size; i++) {
HInstruction* load = removed_loads_[i];
if (load == nullptr) {
// The load has been handled in the scan for type conversion below.
DCHECK(substitute_instructions_for_loads_[i]->IsTypeConversion());
continue;
}
DCHECK(load->IsInstanceFieldGet() ||
load->IsStaticFieldGet() ||
load->IsArrayGet());
HInstruction* substitute = substitute_instructions_for_loads_[i];
DCHECK(substitute != nullptr);
// We proactively retrieve the substitute for a removed load, so
// a load that has a substitute should not be observed as a heap
// location value.
DCHECK_EQ(FindSubstitute(substitute), substitute);
// The load expects to load the heap value as type load->GetType().
// However the tracked heap value may not be of that type. An explicit
// type conversion may be needed.
// There are actually three types involved here:
// (1) tracked heap value's type (type A)
// (2) heap location (field or element)'s type (type B)
// (3) load's type (type C)
// We guarantee that type A stored as type B and then fetched out as
// type C is the same as casting from type A to type C directly, since
// type B and type C will have the same size which is guarenteed in
// HInstanceFieldGet/HStaticFieldGet/HArrayGet's SetType().
// So we only need one type conversion from type A to type C.
HTypeConversion* type_conversion = AddTypeConversionIfNecessary(
load, substitute, load->GetType());
if (type_conversion != nullptr) {
TryToReuseTypeConversion(type_conversion, i);
load->ReplaceWith(type_conversion);
substitute_instructions_for_loads_[i] = type_conversion;
} else {
load->ReplaceWith(substitute);
}
load->GetBlock()->RemoveInstruction(load);
}
// At this point, stores in possibly_removed_stores_ can be safely removed.
for (HInstruction* store : possibly_removed_stores_) {
DCHECK(store->IsInstanceFieldSet() || store->IsStaticFieldSet() || store->IsArraySet());
store->GetBlock()->RemoveInstruction(store);
}
// Eliminate singleton-classified instructions:
// * - Constructor fences (they never escape this thread).
// * - Allocations (if they are unused).
for (HInstruction* new_instance : singleton_new_instances_) {
size_t removed = HConstructorFence::RemoveConstructorFences(new_instance);
MaybeRecordStat(stats_,
MethodCompilationStat::kConstructorFenceRemovedLSE,
removed);
if (!new_instance->HasNonEnvironmentUses()) {
new_instance->RemoveEnvironmentUsers();
new_instance->GetBlock()->RemoveInstruction(new_instance);
}
}
}
private:
static bool IsLoad(HInstruction* instruction) {
if (instruction == kUnknownHeapValue || instruction == kDefaultHeapValue) {
return false;
}
// Unresolved load is not treated as a load.
return instruction->IsInstanceFieldGet() ||
instruction->IsStaticFieldGet() ||
instruction->IsArrayGet();
}
static bool IsStore(HInstruction* instruction) {
if (instruction == kUnknownHeapValue || instruction == kDefaultHeapValue) {
return false;
}
// Unresolved store is not treated as a store.
return instruction->IsInstanceFieldSet() ||
instruction->IsArraySet() ||
instruction->IsStaticFieldSet();
}
// Returns the real heap value by finding its substitute or by "peeling"
// a store instruction.
HInstruction* GetRealHeapValue(HInstruction* heap_value) {
if (IsLoad(heap_value)) {
return FindSubstitute(heap_value);
}
if (!IsStore(heap_value)) {
return heap_value;
}
// We keep track of store instructions as the heap values which might be
// eliminated if the stores are later found not necessary. The real stored
// value needs to be fetched from the store instruction.
if (heap_value->IsInstanceFieldSet()) {
heap_value = heap_value->AsInstanceFieldSet()->GetValue();
} else if (heap_value->IsStaticFieldSet()) {
heap_value = heap_value->AsStaticFieldSet()->GetValue();
} else {
DCHECK(heap_value->IsArraySet());
heap_value = heap_value->AsArraySet()->GetValue();
}
// heap_value may already be a removed load.
return FindSubstitute(heap_value);
}
// If heap_value is a store, need to keep the store.
// This is necessary if a heap value is killed or replaced by another value,
// so that the store is no longer used to track heap value.
void KeepIfIsStore(HInstruction* heap_value) {
if (!IsStore(heap_value)) {
return;
}
auto idx = std::find(possibly_removed_stores_.begin(),
possibly_removed_stores_.end(), heap_value);
if (idx != possibly_removed_stores_.end()) {
// Make sure the store is kept.
possibly_removed_stores_.erase(idx);
}
}
// If a heap location X may alias with heap location at `loc_index`
// and heap_values of that heap location X holds a store, keep that store.
// It's needed for a dependent load that's not eliminated since any store
// that may put value into the load's heap location needs to be kept.
void KeepStoresIfAliasedToLocation(ScopedArenaVector<HInstruction*>& heap_values,
size_t loc_index) {
for (size_t i = 0; i < heap_values.size(); i++) {
if ((i == loc_index) || heap_location_collector_.MayAlias(i, loc_index)) {
KeepIfIsStore(heap_values[i]);
}
}
}
void HandleLoopSideEffects(HBasicBlock* block) {
DCHECK(block->IsLoopHeader());
int block_id = block->GetBlockId();
ScopedArenaVector<HInstruction*>& heap_values = heap_values_for_[block_id];
HBasicBlock* pre_header = block->GetLoopInformation()->GetPreHeader();
ScopedArenaVector<HInstruction*>& pre_header_heap_values =
heap_values_for_[pre_header->GetBlockId()];
// Don't eliminate loads in irreducible loops.
// Also keep the stores before the loop.
if (block->GetLoopInformation()->IsIrreducible()) {
if (kIsDebugBuild) {
for (size_t i = 0; i < heap_values.size(); i++) {
DCHECK_EQ(heap_values[i], kUnknownHeapValue);
}
}
for (size_t i = 0; i < heap_values.size(); i++) {
KeepIfIsStore(pre_header_heap_values[i]);
}
return;
}
// Inherit the values from pre-header.
for (size_t i = 0; i < heap_values.size(); i++) {
heap_values[i] = pre_header_heap_values[i];
}
// We do a single pass in reverse post order. For loops, use the side effects as a hint
// to see if the heap values should be killed.
if (side_effects_.GetLoopEffects(block).DoesAnyWrite()) {
for (size_t i = 0; i < heap_values.size(); i++) {
HeapLocation* location = heap_location_collector_.GetHeapLocation(i);
ReferenceInfo* ref_info = location->GetReferenceInfo();
if (ref_info->IsSingleton() && !location->IsValueKilledByLoopSideEffects()) {
// A singleton's field that's not stored into inside a loop is
// invariant throughout the loop. Nothing to do.
} else {
// heap value is killed by loop side effects.
KeepIfIsStore(pre_header_heap_values[i]);
heap_values[i] = kUnknownHeapValue;
}
}
} else {
// The loop doesn't kill any value.
}
}
void MergePredecessorValues(HBasicBlock* block) {
ArrayRef<HBasicBlock* const> predecessors(block->GetPredecessors());
if (predecessors.size() == 0) {
return;
}
if (block->IsExitBlock()) {
// Exit block doesn't really merge values since the control flow ends in
// its predecessors. Each predecessor needs to make sure stores are kept
// if necessary.
return;
}
ScopedArenaVector<HInstruction*>& heap_values = heap_values_for_[block->GetBlockId()];
for (size_t i = 0; i < heap_values.size(); i++) {
HInstruction* merged_value = nullptr;
// If we can merge the store itself from the predecessors, we keep
// the store as the heap value as long as possible. In case we cannot
// merge the store, we try to merge the values of the stores.
HInstruction* merged_store_value = nullptr;
// Whether merged_value is a result that's merged from all predecessors.
bool from_all_predecessors = true;
ReferenceInfo* ref_info = heap_location_collector_.GetHeapLocation(i)->GetReferenceInfo();
HInstruction* ref = ref_info->GetReference();
HInstruction* singleton_ref = nullptr;
if (ref_info->IsSingleton()) {
// We do more analysis based on singleton's liveness when merging
// heap values for such cases.
singleton_ref = ref;
}
for (HBasicBlock* predecessor : predecessors) {
HInstruction* pred_value = heap_values_for_[predecessor->GetBlockId()][i];
if (!IsStore(pred_value)) {
pred_value = FindSubstitute(pred_value);
}
DCHECK(pred_value != nullptr);
HInstruction* pred_store_value = GetRealHeapValue(pred_value);
if ((singleton_ref != nullptr) &&
!singleton_ref->GetBlock()->Dominates(predecessor)) {
// singleton_ref is not live in this predecessor. No need to merge
// since singleton_ref is not live at the beginning of this block.
DCHECK_EQ(pred_value, kUnknownHeapValue);
from_all_predecessors = false;
break;
}
if (merged_value == nullptr) {
// First seen heap value.
DCHECK(pred_value != nullptr);
merged_value = pred_value;
} else if (pred_value != merged_value) {
// There are conflicting values.
merged_value = kUnknownHeapValue;
// We may still be able to merge store values.
}
// Conflicting stores may be storing the same value. We do another merge
// of real stored values.
if (merged_store_value == nullptr) {
// First seen store value.
DCHECK(pred_store_value != nullptr);
merged_store_value = pred_store_value;
} else if (pred_store_value != merged_store_value) {
// There are conflicting store values.
merged_store_value = kUnknownHeapValue;
// There must be conflicting stores also.
DCHECK_EQ(merged_value, kUnknownHeapValue);
// No need to merge anymore.
break;
}
}
if (merged_value == nullptr) {
DCHECK(!from_all_predecessors);
DCHECK(singleton_ref != nullptr);
}
if (from_all_predecessors) {
if (ref_info->IsSingletonAndRemovable() &&
(block->IsSingleReturnOrReturnVoidAllowingPhis() ||
(block->EndsWithReturn() && (merged_value != kUnknownHeapValue ||
merged_store_value != kUnknownHeapValue)))) {
// Values in the singleton are not needed anymore:
// (1) if this block consists of a sole return, or
// (2) if this block returns and a usable merged value is obtained
// (loads prior to the return will always use that value).
} else if (!IsStore(merged_value)) {
// We don't track merged value as a store anymore. We have to
// hold the stores in predecessors live here.
for (HBasicBlock* predecessor : predecessors) {
ScopedArenaVector<HInstruction*>& pred_values =
heap_values_for_[predecessor->GetBlockId()];
KeepIfIsStore(pred_values[i]);
}
}
} else {
DCHECK(singleton_ref != nullptr);
// singleton_ref is non-existing at the beginning of the block. There is
// no need to keep the stores.
}
if (!from_all_predecessors) {
DCHECK(singleton_ref != nullptr);
DCHECK((singleton_ref->GetBlock() == block) ||
!singleton_ref->GetBlock()->Dominates(block))
<< "method: " << GetGraph()->GetMethodName();
// singleton_ref is not defined before block or defined only in some of its
// predecessors, so block doesn't really have the location at its entry.
heap_values[i] = kUnknownHeapValue;
} else if (predecessors.size() == 1) {
// Inherit heap value from the single predecessor.
DCHECK_EQ(heap_values_for_[predecessors[0]->GetBlockId()][i], merged_value);
heap_values[i] = merged_value;
} else {
DCHECK(merged_value == kUnknownHeapValue ||
merged_value == kDefaultHeapValue ||
merged_value->GetBlock()->Dominates(block));
if (merged_value != kUnknownHeapValue) {
heap_values[i] = merged_value;
} else {
// Stores in different predecessors may be storing the same value.
heap_values[i] = merged_store_value;
}
}
}
}
// `instruction` is being removed. Try to see if the null check on it
// can be removed. This can happen if the same value is set in two branches
// but not in dominators. Such as:
// int[] a = foo();
// if () {
// a[0] = 2;
// } else {
// a[0] = 2;
// }
// // a[0] can now be replaced with constant 2, and the null check on it can be removed.
void TryRemovingNullCheck(HInstruction* instruction) {
HInstruction* prev = instruction->GetPrevious();
if ((prev != nullptr) && prev->IsNullCheck() && (prev == instruction->InputAt(0))) {
// Previous instruction is a null check for this instruction. Remove the null check.
prev->ReplaceWith(prev->InputAt(0));
prev->GetBlock()->RemoveInstruction(prev);
}
}
HInstruction* GetDefaultValue(DataType::Type type) {
switch (type) {
case DataType::Type::kReference:
return GetGraph()->GetNullConstant();
case DataType::Type::kBool:
case DataType::Type::kUint8:
case DataType::Type::kInt8:
case DataType::Type::kUint16:
case DataType::Type::kInt16:
case DataType::Type::kInt32:
return GetGraph()->GetIntConstant(0);
case DataType::Type::kInt64:
return GetGraph()->GetLongConstant(0);
case DataType::Type::kFloat32:
return GetGraph()->GetFloatConstant(0);
case DataType::Type::kFloat64:
return GetGraph()->GetDoubleConstant(0);
default:
UNREACHABLE();
}
}
void VisitGetLocation(HInstruction* instruction, size_t idx) {
DCHECK_NE(idx, HeapLocationCollector::kHeapLocationNotFound);
ScopedArenaVector<HInstruction*>& heap_values =
heap_values_for_[instruction->GetBlock()->GetBlockId()];
HInstruction* heap_value = heap_values[idx];
if (heap_value == kDefaultHeapValue) {
HInstruction* constant = GetDefaultValue(instruction->GetType());
AddRemovedLoad(instruction, constant);
heap_values[idx] = constant;
return;
}
heap_value = GetRealHeapValue(heap_value);
if (heap_value == kUnknownHeapValue) {
// Load isn't eliminated. Put the load as the value into the HeapLocation.
// This acts like GVN but with better aliasing analysis.
heap_values[idx] = instruction;
KeepStoresIfAliasedToLocation(heap_values, idx);
} else {
// Load is eliminated.
AddRemovedLoad(instruction, heap_value);
TryRemovingNullCheck(instruction);
}
}
bool Equal(HInstruction* heap_value, HInstruction* value) {
DCHECK(!IsStore(value)) << value->DebugName();
if (heap_value == kUnknownHeapValue) {
// Don't compare kUnknownHeapValue with other values.
return false;
}
if (heap_value == value) {
return true;
}
if (heap_value == kDefaultHeapValue && GetDefaultValue(value->GetType()) == value) {
return true;
}
HInstruction* real_heap_value = GetRealHeapValue(heap_value);
if (real_heap_value != heap_value) {
return Equal(real_heap_value, value);
}
return false;
}
void VisitSetLocation(HInstruction* instruction, size_t idx, HInstruction* value) {
DCHECK_NE(idx, HeapLocationCollector::kHeapLocationNotFound);
DCHECK(!IsStore(value)) << value->DebugName();
// value may already have a substitute.
value = FindSubstitute(value);
ScopedArenaVector<HInstruction*>& heap_values =
heap_values_for_[instruction->GetBlock()->GetBlockId()];
HInstruction* heap_value = heap_values[idx];
bool possibly_redundant = false;
if (Equal(heap_value, value)) {
// Store into the heap location with the same value.
// This store can be eliminated right away.
instruction->GetBlock()->RemoveInstruction(instruction);
return;
} else {
HLoopInformation* loop_info = instruction->GetBlock()->GetLoopInformation();
if (loop_info == nullptr) {
// Store is not in a loop. We try to precisely track the heap value by
// the store.
possibly_redundant = true;
} else if (!loop_info->IsIrreducible()) {
// instruction is a store in the loop so the loop must do write.
DCHECK(side_effects_.GetLoopEffects(loop_info->GetHeader()).DoesAnyWrite());
ReferenceInfo* ref_info = heap_location_collector_.GetHeapLocation(idx)->GetReferenceInfo();
if (ref_info->IsSingleton() && !loop_info->IsDefinedOutOfTheLoop(ref_info->GetReference())) {
// original_ref is created inside the loop. Value stored to it isn't needed at
// the loop header. This is true for outer loops also.
possibly_redundant = true;
} else {
// Keep the store since its value may be needed at the loop header.
}
} else {
// Keep the store inside irreducible loops.
}
}
if (possibly_redundant) {
possibly_removed_stores_.push_back(instruction);
}
// Put the store as the heap value. If the value is loaded or needed after
// return/deoptimization later, this store isn't really redundant.
heap_values[idx] = instruction;
// This store may kill values in other heap locations due to aliasing.
for (size_t i = 0; i < heap_values.size(); i++) {
if (i == idx) {
continue;
}
if (Equal(heap_values[i], value)) {
// Same value should be kept even if aliasing happens.
continue;
}
if (heap_values[i] == kUnknownHeapValue) {
// Value is already unknown, no need for aliasing check.
continue;
}
if (heap_location_collector_.MayAlias(i, idx)) {
// Kill heap locations that may alias and as a result if the heap value
// is a store, the store needs to be kept.
KeepIfIsStore(heap_values[i]);
heap_values[i] = kUnknownHeapValue;
}
}
}
void VisitInstanceFieldGet(HInstanceFieldGet* instruction) override {
HInstruction* object = instruction->InputAt(0);
const FieldInfo& field = instruction->GetFieldInfo();
VisitGetLocation(instruction, heap_location_collector_.GetFieldHeapLocation(object, &field));
}
void VisitInstanceFieldSet(HInstanceFieldSet* instruction) override {
HInstruction* object = instruction->InputAt(0);
const FieldInfo& field = instruction->GetFieldInfo();
HInstruction* value = instruction->InputAt(1);
size_t idx = heap_location_collector_.GetFieldHeapLocation(object, &field);
VisitSetLocation(instruction, idx, value);
}
void VisitStaticFieldGet(HStaticFieldGet* instruction) override {
HInstruction* cls = instruction->InputAt(0);
const FieldInfo& field = instruction->GetFieldInfo();
VisitGetLocation(instruction, heap_location_collector_.GetFieldHeapLocation(cls, &field));
}
void VisitStaticFieldSet(HStaticFieldSet* instruction) override {
HInstruction* cls = instruction->InputAt(0);
const FieldInfo& field = instruction->GetFieldInfo();
size_t idx = heap_location_collector_.GetFieldHeapLocation(cls, &field);
VisitSetLocation(instruction, idx, instruction->InputAt(1));
}
void VisitArrayGet(HArrayGet* instruction) override {
VisitGetLocation(instruction, heap_location_collector_.GetArrayHeapLocation(instruction));
}
void VisitArraySet(HArraySet* instruction) override {
size_t idx = heap_location_collector_.GetArrayHeapLocation(instruction);
VisitSetLocation(instruction, idx, instruction->InputAt(2));
}
void VisitDeoptimize(HDeoptimize* instruction) override {
const ScopedArenaVector<HInstruction*>& heap_values =
heap_values_for_[instruction->GetBlock()->GetBlockId()];
for (HInstruction* heap_value : heap_values) {
// A store is kept as the heap value for possibly removed stores.
// That value stored is generally observeable after deoptimization, except
// for singletons that don't escape after deoptimization.
if (IsStore(heap_value)) {
if (heap_value->IsStaticFieldSet()) {
KeepIfIsStore(heap_value);
continue;
}
HInstruction* reference = heap_value->InputAt(0);
if (heap_location_collector_.FindReferenceInfoOf(reference)->IsSingleton()) {
if (reference->IsNewInstance() && reference->AsNewInstance()->IsFinalizable()) {
// Finalizable objects alway escape.
KeepIfIsStore(heap_value);
continue;
}
// Check whether the reference for a store is used by an environment local of
// HDeoptimize. If not, the singleton is not observed after
// deoptimizion.
for (const HUseListNode<HEnvironment*>& use : reference->GetEnvUses()) {
HEnvironment* user = use.GetUser();
if (user->GetHolder() == instruction) {
// The singleton for the store is visible at this deoptimization
// point. Need to keep the store so that the heap value is
// seen by the interpreter.
KeepIfIsStore(heap_value);
}
}
} else {
KeepIfIsStore(heap_value);
}
}
}
}
// Keep necessary stores before exiting a method via return/throw.
void HandleExit(HBasicBlock* block) {
const ScopedArenaVector<HInstruction*>& heap_values =
heap_values_for_[block->GetBlockId()];
for (size_t i = 0; i < heap_values.size(); i++) {
HInstruction* heap_value = heap_values[i];
ReferenceInfo* ref_info = heap_location_collector_.GetHeapLocation(i)->GetReferenceInfo();
if (!ref_info->IsSingletonAndRemovable()) {
KeepIfIsStore(heap_value);
}
}
}
void VisitReturn(HReturn* instruction) override {
HandleExit(instruction->GetBlock());
}
void VisitReturnVoid(HReturnVoid* return_void) override {
HandleExit(return_void->GetBlock());
}
void VisitThrow(HThrow* throw_instruction) override {
HandleExit(throw_instruction->GetBlock());
}
void HandleInvoke(HInstruction* instruction) {
SideEffects side_effects = instruction->GetSideEffects();
ScopedArenaVector<HInstruction*>& heap_values =
heap_values_for_[instruction->GetBlock()->GetBlockId()];
for (size_t i = 0; i < heap_values.size(); i++) {
ReferenceInfo* ref_info = heap_location_collector_.GetHeapLocation(i)->GetReferenceInfo();
if (ref_info->IsSingleton()) {
// Singleton references cannot be seen by the callee.
} else {
if (side_effects.DoesAnyRead()) {
// Invocation may read the heap value.
KeepIfIsStore(heap_values[i]);
}
if (side_effects.DoesAnyWrite()) {
// Keep the store since it's not used to track the heap value anymore.
KeepIfIsStore(heap_values[i]);
heap_values[i] = kUnknownHeapValue;
}
}
}
}
void VisitInvoke(HInvoke* invoke) override {
HandleInvoke(invoke);
}
void VisitClinitCheck(HClinitCheck* clinit) override {
HandleInvoke(clinit);
}
void VisitUnresolvedInstanceFieldGet(HUnresolvedInstanceFieldGet* instruction) override {
// Conservatively treat it as an invocation.
HandleInvoke(instruction);
}
void VisitUnresolvedInstanceFieldSet(HUnresolvedInstanceFieldSet* instruction) override {
// Conservatively treat it as an invocation.
HandleInvoke(instruction);
}
void VisitUnresolvedStaticFieldGet(HUnresolvedStaticFieldGet* instruction) override {
// Conservatively treat it as an invocation.
HandleInvoke(instruction);
}
void VisitUnresolvedStaticFieldSet(HUnresolvedStaticFieldSet* instruction) override {
// Conservatively treat it as an invocation.
HandleInvoke(instruction);
}
void VisitNewInstance(HNewInstance* new_instance) override {
ReferenceInfo* ref_info = heap_location_collector_.FindReferenceInfoOf(new_instance);
if (ref_info == nullptr) {
// new_instance isn't used for field accesses. No need to process it.
return;
}
if (ref_info->IsSingletonAndRemovable() && !new_instance->NeedsChecks()) {
DCHECK(!new_instance->IsFinalizable());
// new_instance can potentially be eliminated.
singleton_new_instances_.push_back(new_instance);
}
ScopedArenaVector<HInstruction*>& heap_values =
heap_values_for_[new_instance->GetBlock()->GetBlockId()];
for (size_t i = 0; i < heap_values.size(); i++) {
HInstruction* ref =
heap_location_collector_.GetHeapLocation(i)->GetReferenceInfo()->GetReference();
size_t offset = heap_location_collector_.GetHeapLocation(i)->GetOffset();
if (ref == new_instance && offset >= mirror::kObjectHeaderSize) {
// Instance fields except the header fields are set to default heap values.
heap_values[i] = kDefaultHeapValue;
}
}
}
void VisitNewArray(HNewArray* new_array) override {
ReferenceInfo* ref_info = heap_location_collector_.FindReferenceInfoOf(new_array);
if (ref_info == nullptr) {
// new_array isn't used for array accesses. No need to process it.
return;
}
if (ref_info->IsSingletonAndRemovable()) {
if (new_array->GetLength()->IsIntConstant() &&
new_array->GetLength()->AsIntConstant()->GetValue() >= 0) {
// new_array can potentially be eliminated.
singleton_new_instances_.push_back(new_array);
} else {
// new_array may throw NegativeArraySizeException. Keep it.
}
}
ScopedArenaVector<HInstruction*>& heap_values =
heap_values_for_[new_array->GetBlock()->GetBlockId()];
for (size_t i = 0; i < heap_values.size(); i++) {
HeapLocation* location = heap_location_collector_.GetHeapLocation(i);
HInstruction* ref = location->GetReferenceInfo()->GetReference();
if (ref == new_array && location->GetIndex() != nullptr) {
// Array elements are set to default heap values.
heap_values[i] = kDefaultHeapValue;
}
}
}
const HeapLocationCollector& heap_location_collector_;
const SideEffectsAnalysis& side_effects_;
// Use local allocator for allocating memory.
ScopedArenaAllocator allocator_;
// One array of heap values for each block.
ScopedArenaVector<ScopedArenaVector<HInstruction*>> heap_values_for_;
// We record the instructions that should be eliminated but may be
// used by heap locations. They'll be removed in the end.
ScopedArenaVector<HInstruction*> removed_loads_;
ScopedArenaVector<HInstruction*> substitute_instructions_for_loads_;
// Stores in this list may be removed from the list later when it's
// found that the store cannot be eliminated.
ScopedArenaVector<HInstruction*> possibly_removed_stores_;
ScopedArenaVector<HInstruction*> singleton_new_instances_;
DISALLOW_COPY_AND_ASSIGN(LSEVisitor);
};
bool LoadStoreElimination::Run() {
if (graph_->IsDebuggable() || graph_->HasTryCatch()) {
// Debugger may set heap values or trigger deoptimization of callers.
// Try/catch support not implemented yet.
// Skip this optimization.
return false;
}
const HeapLocationCollector& heap_location_collector = lsa_.GetHeapLocationCollector();
if (heap_location_collector.GetNumberOfHeapLocations() == 0) {
// No HeapLocation information from LSA, skip this optimization.
return false;
}
// TODO: analyze VecLoad/VecStore better.
if (graph_->HasSIMD()) {
return false;
}
LSEVisitor lse_visitor(graph_, heap_location_collector, side_effects_, stats_);
for (HBasicBlock* block : graph_->GetReversePostOrder()) {
lse_visitor.VisitBasicBlock(block);
}
lse_visitor.RemoveInstructions();
return true;
}
} // namespace art