chromium/v8/src/compiler/typed-optimization.cc

// Copyright 2016 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/typed-optimization.h"

#include <optional>

#include "src/compiler/compilation-dependencies.h"
#include "src/compiler/js-graph.h"
#include "src/compiler/js-heap-broker.h"
#include "src/compiler/node-matchers.h"
#include "src/compiler/node-properties.h"
#include "src/compiler/simplified-operator.h"
#include "src/compiler/type-cache.h"
#include "src/execution/isolate-inl.h"

namespace v8 {
namespace internal {
namespace compiler {

TypedOptimization::TypedOptimization(Editor* editor,
                                     CompilationDependencies* dependencies,
                                     JSGraph* jsgraph, JSHeapBroker* broker)
    : … { … }

TypedOptimization::~TypedOptimization() = default;

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

namespace {

OptionalMapRef GetStableMapFromObjectType(JSHeapBroker* broker,
                                          Type object_type) { … }

Node* ResolveSameValueRenames(Node* node) { … }

}  // namespace

Reduction TypedOptimization::ReduceConvertReceiver(Node* node) { … }

Reduction TypedOptimization::ReduceCheckHeapObject(Node* node) { … }

Reduction TypedOptimization::ReduceMaybeGrowFastElements(Node* node) { … }

Reduction TypedOptimization::ReduceCheckBounds(Node* node) { … }

Reduction TypedOptimization::ReduceCheckNotTaggedHole(Node* node) { … }

Reduction TypedOptimization::ReduceCheckMaps(Node* node) { … }

Reduction TypedOptimization::ReduceCheckNumber(Node* node) { … }

Reduction TypedOptimization::ReduceCheckString(Node* node) { … }

Reduction TypedOptimization::ReduceCheckStringOrStringWrapper(Node* node) { … }

Reduction TypedOptimization::ReduceCheckEqualsInternalizedString(Node* node) { … }

Reduction TypedOptimization::ReduceCheckEqualsSymbol(Node* node) { … }

Reduction TypedOptimization::ReduceLoadField(Node* node) { … }

Reduction TypedOptimization::ReduceNumberFloor(Node* node) { … }

Reduction TypedOptimization::ReduceNumberRoundop(Node* node) { … }

Reduction TypedOptimization::ReduceNumberSilenceNaN(Node* node) { … }

Reduction TypedOptimization::ReduceNumberToUint8Clamped(Node* node) { … }

Reduction TypedOptimization::ReducePhi(Node* node) { … }

Reduction TypedOptimization::ReduceReferenceEqual(Node* node) { … }

const Operator* TypedOptimization::NumberComparisonFor(const Operator* op) { … }

Reduction TypedOptimization::
    TryReduceStringComparisonOfStringFromSingleCharCodeToConstant(
        Node* comparison, StringRef string, bool inverted) { … }

// Try to reduces a string comparison of the form
// String.fromCharCode(x) {comparison} {constant} if inverted is false,
// and {constant} {comparison} String.fromCharCode(x) if inverted is true.
Reduction
TypedOptimization::TryReduceStringComparisonOfStringFromSingleCharCode(
    Node* comparison, Node* from_char_code, Type constant_type, bool inverted) { … }

Reduction TypedOptimization::ReduceStringComparison(Node* node) { … }

Reduction TypedOptimization::ReduceStringLength(Node* node) { … }

Reduction TypedOptimization::ReduceSameValue(Node* node) { … }

Reduction TypedOptimization::ReduceSelect(Node* node) { … }

Reduction TypedOptimization::ReduceSpeculativeToNumber(Node* node) { … }

Reduction TypedOptimization::ReduceTypeOf(Node* node) { … }

Reduction TypedOptimization::ReduceToBoolean(Node* node) { … }

namespace {
bool BothAre(Type t1, Type t2, Type t3) { … }

bool NeitherCanBe(Type t1, Type t2, Type t3) { … }

const Operator* NumberOpFromSpeculativeNumberOp(
    SimplifiedOperatorBuilder* simplified, const Operator* op) { … }

}  // namespace

Reduction TypedOptimization::ReduceSpeculativeNumberAdd(Node* node) { … }

Reduction TypedOptimization::ReduceJSToNumberInput(Node* input) { … }

Node* TypedOptimization::ConvertPlainPrimitiveToNumber(Node* node) { … }

Reduction TypedOptimization::ReduceSpeculativeNumberBinop(Node* node) { … }

Reduction TypedOptimization::ReduceSpeculativeNumberComparison(Node* node) { … }

Factory* TypedOptimization::factory() const { … }

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

SimplifiedOperatorBuilder* TypedOptimization::simplified() const { … }

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