escape-analysis.cc | Explore in Territory

// Copyright 2017 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/escape-analysis.h"

#include "src/codegen/tick-counter.h"
#include "src/compiler/frame-states.h"
#include "src/compiler/node-matchers.h"
#include "src/compiler/operator-properties.h"
#include "src/compiler/simplified-operator.h"
#include "src/compiler/state-values-utils.h"
#include "src/handles/handles-inl.h"
#include "src/objects/map-inl.h"

#ifdef DEBUG
#define TRACE …
#else
#define TRACE …
#endif

namespace v8 {
namespace internal {
namespace compiler {

template <class T>
class Sidetable { … };

template <class T>
class SparseSidetable { … };

// Keeps track of the changes to the current node during reduction.
// Encapsulates the current state of the IR graph and the reducer state like
// side-tables. All access to the IR and the reducer state should happen through
// a ReduceScope to ensure that changes and dependencies are tracked and all
// necessary node revisitations happen.
class ReduceScope { … };

// A VariableTracker object keeps track of the values of variables at all points
// of the effect chain and introduces new phi nodes when necessary.
// Initially and by default, variables are mapped to nullptr, which means that
// the variable allocation point does not dominate the current point on the
// effect chain. We map variables that represent uninitialized memory to the
// Dead node to ensure it is not read.
// Unmapped values are impossible by construction, it is indistinguishable if a
// PersistentMap does not contain an element or maps it to the default element.
class VariableTracker { … };

// Encapsulates the current state of the escape analysis reducer to preserve
// invariants regarding changes and re-visitation.
class EscapeAnalysisTracker : public ZoneObject { … };

EffectGraphReducer::EffectGraphReducer(
    Graph* graph, std::function<void(Node*, Reduction*)> reduce,
    TickCounter* tick_counter, Zone* zone)
    : … { … }

void EffectGraphReducer::ReduceFrom(Node* node) { … }

void EffectGraphReducer::Revisit(Node* node) { … }

VariableTracker::VariableTracker(JSGraph* graph, EffectGraphReducer* reducer,
                                 Zone* zone)
    : … { … }

VariableTracker::Scope::Scope(VariableTracker* states, Node* node,
                              Reduction* reduction)
    : … { … }

VariableTracker::Scope::~Scope() { … }

VariableTracker::State VariableTracker::MergeInputs(Node* effect_phi) { … }

namespace {

int OffsetOfFieldAccess(const Operator* op) { … }

Maybe<int> OffsetOfElementAt(ElementAccess const& access, int index) { … }

Maybe<int> OffsetOfElementsAccess(const Operator* op, Node* index_node) { … }

Node* LowerCompareMapsWithoutLoad(Node* checked_map,
                                  ZoneRefSet<Map> const& checked_against,
                                  JSGraph* jsgraph) { … }

void ReduceNode(const Operator* op, EscapeAnalysisTracker::Scope* current,
                JSGraph* jsgraph) { … }

}  // namespace

void EscapeAnalysis::Reduce(Node* node, Reduction* reduction) { … }

EscapeAnalysis::EscapeAnalysis(JSGraph* jsgraph, TickCounter* tick_counter,
                               Zone* zone)
    : … { … }

Node* EscapeAnalysisResult::GetReplacementOf(Node* node) { … }

Node* EscapeAnalysisResult::GetVirtualObjectField(const VirtualObject* vobject,
                                                  int field, Node* effect) { … }

const VirtualObject* EscapeAnalysisResult::GetVirtualObject(Node* node) { … }

VirtualObject::VirtualObject(VariableTracker* var_states, VirtualObject::Id id,
                             int size)
    : … { … }

#undef TRACE

}  // namespace compiler
}  // namespace internal
}  // namespace v8
chromium/v8/src/compiler/escape-analysis.cc
