chromium/v8/src/compiler/node-properties.cc

// Copyright 2015 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/node-properties.h"

#include <optional>

#include "src/compiler/common-operator.h"
#include "src/compiler/graph.h"
#include "src/compiler/js-heap-broker.h"
#include "src/compiler/map-inference.h"
#include "src/compiler/node-matchers.h"
#include "src/compiler/operator-properties.h"
#include "src/compiler/simplified-operator.h"
#include "src/compiler/verifier.h"

namespace v8 {
namespace internal {
namespace compiler {

// static

// static
bool NodeProperties::IsValueEdge(Edge edge) { … }


// static
bool NodeProperties::IsContextEdge(Edge edge) { … }


// static
bool NodeProperties::IsFrameStateEdge(Edge edge) { … }


// static
bool NodeProperties::IsEffectEdge(Edge edge) { … }


// static
bool NodeProperties::IsControlEdge(Edge edge) { … }


// static
bool NodeProperties::IsExceptionalCall(Node* node, Node** out_exception) { … }

// static
Node* NodeProperties::FindSuccessfulControlProjection(Node* node) { … }

// static
void NodeProperties::ReplaceValueInput(Node* node, Node* value, int index) { … }


// static
void NodeProperties::ReplaceValueInputs(Node* node, Node* value) { … }


// static
void NodeProperties::ReplaceContextInput(Node* node, Node* context) { … }


// static
void NodeProperties::ReplaceControlInput(Node* node, Node* control, int index) { … }


// static
void NodeProperties::ReplaceEffectInput(Node* node, Node* effect, int index) { … }


// static
void NodeProperties::ReplaceFrameStateInput(Node* node, Node* frame_state) { … }

// static
void NodeProperties::RemoveNonValueInputs(Node* node) { … }


// static
void NodeProperties::RemoveValueInputs(Node* node) { … }


void NodeProperties::MergeControlToEnd(Graph* graph,
                                       CommonOperatorBuilder* common,
                                       Node* node) { … }

void NodeProperties::RemoveControlFromEnd(Graph* graph,
                                          CommonOperatorBuilder* common,
                                          Node* node) { … }

// static
void NodeProperties::ReplaceUses(Node* node, Node* value, Node* effect,
                                 Node* success, Node* exception) { … }


// static
void NodeProperties::ChangeOp(Node* node, const Operator* new_op) { … }

// static
void NodeProperties::ChangeOpUnchecked(Node* node, const Operator* new_op) { … }

// static
Node* NodeProperties::FindFrameStateBefore(Node* node,
                                           Node* unreachable_sentinel) { … }

// static
Node* NodeProperties::FindProjection(Node* node, size_t projection_index) { … }


// static
void NodeProperties::CollectValueProjections(Node* node, Node** projections,
                                             size_t projection_count) { … }


// static
void NodeProperties::CollectControlProjections(Node* node, Node** projections,
                                               size_t projection_count) { … }

// static
MachineRepresentation NodeProperties::GetProjectionType(
    Node const* projection) { … }

// static
bool NodeProperties::IsSame(Node* a, Node* b) { … }

// static
OptionalMapRef NodeProperties::GetJSCreateMap(JSHeapBroker* broker,
                                              Node* receiver) { … }

// static
NodeProperties::InferMapsResult NodeProperties::InferMapsUnsafe(
    JSHeapBroker* broker, Node* receiver, Effect effect,
    ZoneRefSet<Map>* maps_out) { … }

// static
bool NodeProperties::NoObservableSideEffectBetween(Node* effect,
                                                   Node* dominator) { … }

// static
bool NodeProperties::CanBePrimitive(JSHeapBroker* broker, Node* receiver,
                                    Effect effect) { … }

// static
bool NodeProperties::CanBeNullOrUndefined(JSHeapBroker* broker, Node* receiver,
                                          Effect effect) { … }

// static
Node* NodeProperties::GetOuterContext(Node* node, size_t* depth) { … }

// static
Type NodeProperties::GetTypeOrAny(const Node* node) { … }

// static
bool NodeProperties::AllValueInputsAreTyped(Node* node) { … }

// static
bool NodeProperties::IsInputRange(Edge edge, int first, int num) { … }

// static
size_t NodeProperties::HashCode(Node* node) { … }

// static
bool NodeProperties::Equals(Node* a, Node* b) { … }

}  // namespace compiler
}  // namespace internal
}  // namespace v8