csa-load-elimination.cc | Explore in Territory

// 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.

#include "src/compiler/csa-load-elimination.h"

#include "src/compiler/common-operator.h"
#include "src/compiler/node-matchers.h"
#include "src/compiler/node-properties.h"
#include "src/compiler/simplified-operator.h"

namespace v8 {
namespace internal {
namespace compiler {

Reduction CsaLoadElimination::Reduce(Node* node) { … }

namespace CsaLoadEliminationHelpers {

bool Subsumes(MachineRepresentation from, MachineRepresentation to) { … }

bool IsConstantObject(Node* object) { … }

bool IsFreshObject(Node* object) { … }

}  // namespace CsaLoadEliminationHelpers

Helpers;

// static
template <typename OuterKey>
void CsaLoadElimination::HalfState::IntersectWith(
    OuterMap<OuterKey>& to, const OuterMap<OuterKey>& from) { … }

void CsaLoadElimination::HalfState::IntersectWith(HalfState const* that) { … }

CsaLoadElimination::HalfState const* CsaLoadElimination::HalfState::KillField(
    Node* object, Node* offset, MachineRepresentation repr) const { … }

CsaLoadElimination::HalfState const* CsaLoadElimination::HalfState::AddField(
    Node* object, Node* offset, Node* value, MachineRepresentation repr) const { … }

CsaLoadElimination::FieldInfo CsaLoadElimination::HalfState::Lookup(
    Node* object, Node* offset) const { … }

// static
// Kill all elements in {infos} that overlap with an element with {offset} and
// size {ElementSizeInBytes(repr)}.
void CsaLoadElimination::HalfState::KillOffset(ConstantOffsetInfos& infos,
                                               uint32_t offset,
                                               MachineRepresentation repr,
                                               Zone* zone) { … }

void CsaLoadElimination::HalfState::KillOffsetInFresh(
    Node* const object, uint32_t offset, MachineRepresentation repr) { … }

// static
void CsaLoadElimination::HalfState::Print(
    const CsaLoadElimination::HalfState::ConstantOffsetInfos& infos) { … }

// static
void CsaLoadElimination::HalfState::Print(
    const CsaLoadElimination::HalfState::UnknownOffsetInfos& infos) { … }

void CsaLoadElimination::HalfState::Print() const { … }

// We may encounter a mutable/immutable inconsistency if the same field offset
// is loaded/stored from the same object both as mutable and immutable. This can
// only happen in code where the object has been cast to two different
// incompatible types, i.e. in unreachable code. For safety, we introduce an
// Unreachable node before the load/store.
Reduction CsaLoadElimination::AssertUnreachable(Node* node) { … }

Reduction CsaLoadElimination::ReduceLoadFromObject(Node* node,
                                                   ObjectAccess const& access) { … }

Reduction CsaLoadElimination::ReduceStoreToObject(Node* node,
                                                  ObjectAccess const& access) { … }

Reduction CsaLoadElimination::ReduceEffectPhi(Node* node) { … }

Reduction CsaLoadElimination::ReduceStart(Node* node) { … }

Reduction CsaLoadElimination::ReduceCall(Node* node) { … }

Reduction CsaLoadElimination::ReduceOtherNode(Node* node) { … }

Reduction CsaLoadElimination::UpdateState(Node* node,
                                          AbstractState const* state) { … }

Reduction CsaLoadElimination::PropagateInputState(Node* node) { … }

CsaLoadElimination::AbstractState const* CsaLoadElimination::ComputeLoopState(
    Node* node, AbstractState const* state) const { … }

Node* CsaLoadElimination::TruncateAndExtend(Node* node,
                                            MachineRepresentation from,
                                            MachineType to) { … }

CommonOperatorBuilder* CsaLoadElimination::common() const { … }

MachineOperatorBuilder* CsaLoadElimination::machine() const { … }

Graph* CsaLoadElimination::graph() const { … }

Isolate* CsaLoadElimination::isolate() const { … }

}  // namespace compiler
}  // namespace internal
}  // namespace v8
chromium/v8/src/compiler/csa-load-elimination.cc
