#include "src/compiler/simplified-operator.h"
#include "include/v8-fast-api-calls.h"
#include "src/base/lazy-instance.h"
#include "src/base/logging.h"
#include "src/compiler/linkage.h"
#include "src/compiler/opcodes.h"
#include "src/compiler/operator.h"
#include "src/compiler/turbofan-types.h"
#include "src/handles/handles-inl.h"
#include "src/objects/feedback-cell.h"
#include "src/objects/map.h"
#include "src/objects/name.h"

Include dependency graph for simplified-operator.cc:

Classes
struct	v8::internal::compiler::SimplifiedOperatorGlobalCache

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::CheckIfOperator< kDeoptimizeReason >

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::FindOrderedHashMapEntryOperator

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::FindOrderedHashMapEntryForInt32KeyOperator

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::FindOrderedHashSetEntryOperator

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::ChangeFloat64ToTaggedOperator< kMode >

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::CheckedInt32MulOperator< kMode >

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::CheckedFloat64ToInt32Operator< kMode >

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::CheckedFloat64ToAdditiveSafeIntegerOperator< kMode >

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::CheckedFloat64ToInt64Operator< kMode >

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::CheckedTaggedToInt32Operator< kMode >

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::CheckedTaggedToAdditiveSafeIntegerOperator< kMode >

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::CheckedTaggedToInt64Operator< kMode >

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::CheckedTaggedToFloat64Operator< kMode >

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::CheckedTruncateTaggedToWord32Operator< kMode >

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::ConvertReceiverOperator< kMode >

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::CheckFloat64HoleNaNOperator< kMode >

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::EnsureWritableFastElementsOperator

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::GrowFastElementsOperator< kMode >

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::LoadFieldByIndexOperator

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::LoadStackArgumentOperator

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::SpeculativeToNumberOperator< kHint >

struct	v8::internal::compiler::SimplifiedOperatorGlobalCache::SpeculativeToBigIntOperator< kHint >

Namespaces
namespace	v8

namespace	v8::internal

namespace	v8::internal::compiler

Macros
#define	PURE_OP_LIST(V)

#define	EFFECT_DEPENDENT_OP_LIST(V)

#define	SPECULATIVE_NUMBER_BINOP_LIST(V)

#define	CHECKED_OP_LIST(V)

#define	CHECKED_WITH_FEEDBACK_OP_LIST(V)

#define	CHECKED_BOUNDS_OP_LIST(V)

#define	PURE(Name, properties, value_input_count, control_input_count)

#define	EFFECT_DEPENDENT(Name, properties, value_input_count, control_input_count)

#define	CHECKED(Name, value_input_count, value_output_count)

#define	CHECKED_WITH_FEEDBACK(Name, value_input_count, value_output_count)

#define	CHECKED_BOUNDS(Name)

#define	CHECK_IF(Name, message)

#define	SPECULATIVE_NUMBER_BINOP(Name)

#define	GET_FROM_CACHE(Name, ...)

#define	GET_FROM_CACHE_WITH_FEEDBACK(Name, value_input_count, value_output_count)

#define	GET_FROM_CACHE_WITH_FEEDBACK(Name)

#define	CASE(Name, ...)

#define	CHECK_IF(Name, message)

#define	SPECULATIVE_BIGINT_BINOP(Name)

#define	MAKE_OR(name, arg2, arg3)

#define	SPECULATIVE_NUMBER_BINOP(Name)

#define	ACCESS_OP_LIST(V)

#define	ACCESS(Name, Type, properties, value_input_count, control_input_count, output_count)

Functions
size_t	v8::internal::compiler::hash_value (BaseTaggedness base_taggedness)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, BaseTaggedness base_taggedness)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, ConstFieldInfo const &const_field_info)

bool	v8::internal::compiler::operator== (ConstFieldInfo const &lhs, ConstFieldInfo const &rhs)

size_t	v8::internal::compiler::hash_value (ConstFieldInfo const &const_field_info)

bool	v8::internal::compiler::operator== (FieldAccess const &lhs, FieldAccess const &rhs)

size_t	v8::internal::compiler::hash_value (FieldAccess const &access)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, FieldAccess const &access)

bool	v8::internal::compiler::operator== (ElementAccess const &lhs, ElementAccess const &rhs)

size_t	v8::internal::compiler::hash_value (ElementAccess const &access)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, ElementAccess const &access)

bool	v8::internal::compiler::operator== (ObjectAccess const &lhs, ObjectAccess const &rhs)

size_t	v8::internal::compiler::hash_value (ObjectAccess const &access)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, ObjectAccess const &access)

const FieldAccess &	v8::internal::compiler::FieldAccessOf (const Operator *op)

const ElementAccess &	v8::internal::compiler::ElementAccessOf (const Operator *op)

const ObjectAccess &	v8::internal::compiler::ObjectAccessOf (const Operator *op)

ExternalArrayType	v8::internal::compiler::ExternalArrayTypeOf (const Operator *op)

ConvertReceiverMode	v8::internal::compiler::ConvertReceiverModeOf (Operator const *op)

size_t	v8::internal::compiler::hash_value (CheckFloat64HoleMode mode)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, CheckFloat64HoleMode mode)

CheckFloat64HoleParameters const &	v8::internal::compiler::CheckFloat64HoleParametersOf (Operator const *op)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, CheckFloat64HoleParameters const &params)

size_t	v8::internal::compiler::hash_value (const CheckFloat64HoleParameters &params)

bool	v8::internal::compiler::operator== (CheckFloat64HoleParameters const &lhs, CheckFloat64HoleParameters const &rhs)

bool	v8::internal::compiler::operator!= (CheckFloat64HoleParameters const &lhs, CheckFloat64HoleParameters const &rhs)

CheckForMinusZeroMode	v8::internal::compiler::CheckMinusZeroModeOf (const Operator *op)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, CheckMapsFlags flags)

bool	v8::internal::compiler::operator== (CheckMapsParameters const &lhs, CheckMapsParameters const &rhs)

size_t	v8::internal::compiler::hash_value (CheckMapsParameters const &p)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, CheckMapsParameters const &p)

CheckMapsParameters const &	v8::internal::compiler::CheckMapsParametersOf (Operator const *op)

ZoneRefSet< Map > const &	v8::internal::compiler::CompareMapsParametersOf (Operator const *op)

ZoneRefSet< Map > const &	v8::internal::compiler::MapGuardMapsOf (Operator const *op)

size_t	v8::internal::compiler::hash_value (CheckTaggedInputMode mode)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, CheckTaggedInputMode mode)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, GrowFastElementsMode mode)

bool	v8::internal::compiler::operator== (const GrowFastElementsParameters &lhs, const GrowFastElementsParameters &rhs)

size_t	v8::internal::compiler::hash_value (const GrowFastElementsParameters &params)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, const GrowFastElementsParameters &params)

const GrowFastElementsParameters &	v8::internal::compiler::GrowFastElementsParametersOf (const Operator *op)

bool	v8::internal::compiler::operator== (ElementsTransition const &lhs, ElementsTransition const &rhs)

bool	v8::internal::compiler::operator== (const ElementsTransitionWithMultipleSources &lhs, const ElementsTransitionWithMultipleSources &rhs)

size_t	v8::internal::compiler::hash_value (ElementsTransition transition)

size_t	v8::internal::compiler::hash_value (ElementsTransitionWithMultipleSources transition)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, ElementsTransition transition)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, ElementsTransitionWithMultipleSources transition)

ElementsTransition const &	v8::internal::compiler::ElementsTransitionOf (const Operator *op)

ElementsTransitionWithMultipleSources const &	v8::internal::compiler::ElementsTransitionWithMultipleSourcesOf (const Operator *op)

MapRef	v8::internal::compiler::DoubleMapParameterOf (const Operator *op)

Type	v8::internal::compiler::ValueTypeParameterOf (const Operator *op)

MapRef	v8::internal::compiler::FastMapParameterOf (const Operator *op)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, BigIntOperationHint hint)

size_t	v8::internal::compiler::hash_value (BigIntOperationHint hint)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, NumberOperationHint hint)

size_t	v8::internal::compiler::hash_value (NumberOperationHint hint)

NumberOperationHint	v8::internal::compiler::NumberOperationHintOf (const Operator *op)

BigIntOperationHint	v8::internal::compiler::BigIntOperationHintOf (const Operator *op)

bool	v8::internal::compiler::operator== (NumberOperationParameters const &lhs, NumberOperationParameters const &rhs)

size_t	v8::internal::compiler::hash_value (NumberOperationParameters const &p)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, NumberOperationParameters const &p)

NumberOperationParameters const &	v8::internal::compiler::NumberOperationParametersOf (Operator const *op)

bool	v8::internal::compiler::operator== (BigIntOperationParameters const &lhs, BigIntOperationParameters const &rhs)

size_t	v8::internal::compiler::hash_value (BigIntOperationParameters const &p)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, BigIntOperationParameters const &p)

BigIntOperationParameters const &	v8::internal::compiler::BigIntOperationParametersOf (Operator const *op)

bool	v8::internal::compiler::operator== (SpeculativeBigIntAsNParameters const &lhs, SpeculativeBigIntAsNParameters const &rhs)

size_t	v8::internal::compiler::hash_value (SpeculativeBigIntAsNParameters const &p)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, SpeculativeBigIntAsNParameters const &p)

SpeculativeBigIntAsNParameters const &	v8::internal::compiler::SpeculativeBigIntAsNParametersOf (Operator const *op)

size_t	v8::internal::compiler::hash_value (AllocateParameters info)

V8_EXPORT_PRIVATE std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, AllocateParameters info)

bool	v8::internal::compiler::operator== (AllocateParameters const &lhs, AllocateParameters const &rhs)

const AllocateParameters &	v8::internal::compiler::AllocateParametersOf (const Operator *op)

AllocationType	v8::internal::compiler::AllocationTypeOf (const Operator *op)

Type	v8::internal::compiler::AllocateTypeOf (const Operator *op)

AbortReason	v8::internal::compiler::AbortReasonOf (const Operator *op)

const CheckTaggedInputParameters &	v8::internal::compiler::CheckTaggedInputParametersOf (const Operator *op)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, const CheckTaggedInputParameters &params)

size_t	v8::internal::compiler::hash_value (const CheckTaggedInputParameters &params)

bool	v8::internal::compiler::operator== (CheckTaggedInputParameters const &lhs, CheckTaggedInputParameters const &rhs)

const CheckMinusZeroParameters &	v8::internal::compiler::CheckMinusZeroParametersOf (const Operator *op)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, const CheckMinusZeroParameters &params)

size_t	v8::internal::compiler::hash_value (const CheckMinusZeroParameters &params)

bool	v8::internal::compiler::operator== (CheckMinusZeroParameters const &lhs, CheckMinusZeroParameters const &rhs)

bool	v8::internal::compiler::IsCheckedWithFeedback (const Operator *op)

Handle< FeedbackCell >	v8::internal::compiler::FeedbackCellOf (const Operator *op)

int	v8::internal::compiler::FormalParameterCountOf (const Operator *op)

bool	v8::internal::compiler::operator== (CheckParameters const &lhs, CheckParameters const &rhs)

size_t	v8::internal::compiler::hash_value (CheckParameters const &p)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, CheckParameters const &p)

CheckParameters const &	v8::internal::compiler::CheckParametersOf (Operator const *op)

bool	v8::internal::compiler::operator== (CheckBoundsParameters const &lhs, CheckBoundsParameters const &rhs)

size_t	v8::internal::compiler::hash_value (CheckBoundsParameters const &p)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, CheckBoundsParameters const &p)

CheckBoundsParameters const &	v8::internal::compiler::CheckBoundsParametersOf (Operator const *op)

bool	v8::internal::compiler::operator== (CheckIfParameters const &lhs, CheckIfParameters const &rhs)

size_t	v8::internal::compiler::hash_value (CheckIfParameters const &p)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, CheckIfParameters const &p)

CheckIfParameters const &	v8::internal::compiler::CheckIfParametersOf (Operator const *op)

FastApiCallParameters const &	v8::internal::compiler::FastApiCallParametersOf (const Operator *op)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, FastApiCallParameters const &p)

size_t	v8::internal::compiler::hash_value (FastApiCallParameters const &p)

bool	v8::internal::compiler::operator== (FastApiCallParameters const &lhs, FastApiCallParameters const &rhs)

bool	v8::internal::compiler::operator== (const NewArgumentsElementsParameters &lhs, const NewArgumentsElementsParameters &rhs)

size_t	v8::internal::compiler::hash_value (const NewArgumentsElementsParameters &params)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, const NewArgumentsElementsParameters &params)

const NewArgumentsElementsParameters &	v8::internal::compiler::NewArgumentsElementsParametersOf (const Operator *op)

Macro Definition Documentation

◆ ACCESS

#define ACCESS	(	Name,
		Type,
		properties,
		value_input_count,
		control_input_count,
		output_count )

Value:

  const Operator* SimplifiedOperatorBuilder::Name(const Type& access) {        \
    return zone()->New<Operator1<Type>>(                                       \
        IrOpcode::k##Name,                                                     \
        Operator::kNoDeopt | Operator::kNoThrow | properties, #Name,           \
        value_input_count, 1, control_input_count, output_count, 1, 0,         \
        access);                                                               \
  }

Definition at line 2345 of file simplified-operator.cc.

◆ ACCESS_OP_LIST

#define ACCESS_OP_LIST ( V )

Value:

  V(LoadField, FieldAccess, Operator::kNoWrite, 1, 1, 1)                   \
  V(LoadElement, ElementAccess, Operator::kNoWrite, 2, 1, 1)               \
  V(StoreElement, ElementAccess, Operator::kNoRead, 3, 1, 0)               \
  V(LoadTypedElement, ExternalArrayType, Operator::kNoWrite, 4, 1, 1)      \
  V(StoreTypedElement, ExternalArrayType, Operator::kNoRead, 5, 1, 0)      \
  V(LoadFromObject, ObjectAccess, Operator::kNoWrite, 2, 1, 1)             \
  V(StoreToObject, ObjectAccess, Operator::kNoRead, 3, 1, 0)               \
  V(LoadImmutableFromObject, ObjectAccess, Operator::kNoWrite, 2, 1, 1)    \
  V(InitializeImmutableInObject, ObjectAccess, Operator::kNoRead, 3, 1, 0) \
  V(LoadDataViewElement, ExternalArrayType, Operator::kNoWrite, 4, 1, 1)   \
  V(StoreDataViewElement, ExternalArrayType, Operator::kNoRead, 5, 1, 0)

Definition at line 2332 of file simplified-operator.cc.

◆ CASE

#define CASE	(		Name,
			... )

Value:

case IrOpcode::k##Name:

◆ CHECK_IF [1/2]

#define CHECK_IF	(		Name,
			message )

Value:

CheckIfOperator<DeoptimizeReason::k##Name> kCheckIf##Name;

Definition at line 1081 of file simplified-operator.cc.

◆ CHECK_IF [2/2]

#define CHECK_IF	(		Name,
			message )

Value:

case DeoptimizeReason::k##Name: \

return &cache_.kCheckIf##Name;

Definition at line 1081 of file simplified-operator.cc.

◆ CHECKED

#define CHECKED	(	Name,
		value_input_count,
		value_output_count )

Value:

  struct Name##Operator final : public Operator {                        \
    Name##Operator()                                                     \
        : Operator(IrOpcode::k##Name,                                    \
                   Operator::kFoldable | Operator::kNoThrow, #Name,      \
                   value_input_count, 1, 1, value_output_count, 1, 0) {} \
  };                                                                     \
  Name##Operator k##Name;

Definition at line 1028 of file simplified-operator.cc.

◆ CHECKED_BOUNDS

#define CHECKED_BOUNDS ( Name )

Value:

  struct Name##Operator final : public Operator1<CheckBoundsParameters> {  \
    Name##Operator(FeedbackSource feedback, CheckBoundsFlags flags)        \
        : Operator1<CheckBoundsParameters>(                                \
              IrOpcode::k##Name, Operator::kFoldable | Operator::kNoThrow, \
              #Name, 2, 1, 1, 1, 1, 0,                                     \
              CheckBoundsParameters(feedback, flags)) {}                   \
  };                                                                       \
  Name##Operator k##Name = {FeedbackSource(), CheckBoundsFlags()};         \
  Name##Operator k##Name##Aborting = {FeedbackSource(),                    \
                                      CheckBoundsFlag::kAbortOnOutOfBounds};

Definition at line 1051 of file simplified-operator.cc.

◆ CHECKED_BOUNDS_OP_LIST

#define CHECKED_BOUNDS_OP_LIST ( V )

Value:

V(CheckedUint32Bounds) \

V(CheckedUint64Bounds)

Definition at line 1001 of file simplified-operator.cc.

◆ CHECKED_OP_LIST

#define CHECKED_OP_LIST ( V )

Value:

  V(CheckEqualsInternalizedString, 2, 0)  \
  V(CheckEqualsSymbol, 2, 0)              \
  V(CheckHeapObject, 1, 1)                \
  V(CheckInternalizedString, 1, 1)        \
  V(CheckNotTaggedHole, 1, 1)             \
  V(CheckReceiver, 1, 1)                  \
  V(CheckReceiverOrNullOrUndefined, 1, 1) \
  V(CheckSymbol, 1, 1)                    \
  V(CheckedInt32Add, 2, 1)                \
  V(CheckedInt32Div, 2, 1)                \
  V(CheckedInt32Mod, 2, 1)                \
  V(CheckedInt32Sub, 2, 1)                \
  V(CheckedUint32Div, 2, 1)               \
  V(CheckedUint32Mod, 2, 1)               \
  V(CheckedAdditiveSafeIntegerAdd, 2, 1)  \
  V(CheckedAdditiveSafeIntegerSub, 2, 1)  \
  V(CheckedInt64Add, 2, 1)                \
  V(CheckedInt64Sub, 2, 1)                \
  V(CheckedInt64Mul, 2, 1)                \
  V(CheckedInt64Div, 2, 1)                \
  V(CheckedInt64Mod, 2, 1)

Definition at line 957 of file simplified-operator.cc.

◆ CHECKED_WITH_FEEDBACK

#define CHECKED_WITH_FEEDBACK	(	Name,
		value_input_count,
		value_output_count )

Value:

  struct Name##Operator final : public Operator1<CheckParameters> {        \
    Name##Operator()                                                       \
        : Operator1<CheckParameters>(                                      \
              IrOpcode::k##Name, Operator::kFoldable | Operator::kNoThrow, \
              #Name, value_input_count, 1, 1, value_output_count, 1, 0,    \
              CheckParameters(FeedbackSource())) {}                        \
  };                                                                       \
  Name##Operator k##Name;

Definition at line 1039 of file simplified-operator.cc.

◆ CHECKED_WITH_FEEDBACK_OP_LIST

#define CHECKED_WITH_FEEDBACK_OP_LIST ( V )

Value:

  V(CheckNumber, 1, 1)                   \
  V(CheckNumberFitsInt32, 1, 1)          \
  V(CheckSmi, 1, 1)                      \
  V(CheckString, 1, 1)                   \
  V(CheckStringOrStringWrapper, 1, 1)    \
  V(CheckBigInt, 1, 1)                   \
  V(CheckedBigIntToBigInt64, 1, 1)       \
  V(CheckedInt32ToTaggedSigned, 1, 1)    \
  V(CheckedInt64ToInt32, 1, 1)           \
  V(CheckedInt64ToTaggedSigned, 1, 1)    \
  V(CheckedTaggedToArrayIndex, 1, 1)     \
  V(CheckedTaggedSignedToInt32, 1, 1)    \
  V(CheckedTaggedToTaggedPointer, 1, 1)  \
  V(CheckedTaggedToTaggedSigned, 1, 1)   \
  V(CheckedUint32ToInt32, 1, 1)          \
  V(CheckedUint32ToTaggedSigned, 1, 1)   \
  V(CheckedUint64ToInt32, 1, 1)          \
  V(CheckedUint64ToInt64, 1, 1)          \
  V(CheckedUint64ToTaggedSigned, 1, 1)

Definition at line 980 of file simplified-operator.cc.

◆ EFFECT_DEPENDENT

#define EFFECT_DEPENDENT	(	Name,
		properties,
		value_input_count,
		control_input_count )

Value:

  struct Name##Operator final : public Operator {                           \
    Name##Operator()                                                        \
        : Operator(IrOpcode::k##Name, Operator::kEliminatable | properties, \
                   #Name, value_input_count, 1, control_input_count, 1, 1,  \
                   0) {}                                                    \
  };                                                                        \
  Name##Operator k##Name;

Definition at line 1016 of file simplified-operator.cc.

◆ EFFECT_DEPENDENT_OP_LIST

#define EFFECT_DEPENDENT_OP_LIST ( V )

Value:

  V(BigIntAdd, Operator::kNoProperties, 2, 1)             \
  V(BigIntSubtract, Operator::kNoProperties, 2, 1)        \
  V(BigIntMultiply, Operator::kNoProperties, 2, 1)        \
  V(BigIntDivide, Operator::kNoProperties, 2, 1)          \
  V(BigIntModulus, Operator::kNoProperties, 2, 1)         \
  V(BigIntBitwiseAnd, Operator::kNoProperties, 2, 1)      \
  V(BigIntBitwiseOr, Operator::kNoProperties, 2, 1)       \
  V(BigIntBitwiseXor, Operator::kNoProperties, 2, 1)      \
  V(BigIntShiftLeft, Operator::kNoProperties, 2, 1)       \
  V(BigIntShiftRight, Operator::kNoProperties, 2, 1)      \
  V(StringCharCodeAt, Operator::kNoProperties, 2, 1)      \
  V(StringCodePointAt, Operator::kNoProperties, 2, 1)     \
  V(StringFromCodePointAt, Operator::kNoProperties, 2, 1) \
  V(StringSubstring, Operator::kNoProperties, 3, 1)       \
  V(DateNow, Operator::kNoProperties, 0, 1)               \
  V(DoubleArrayMax, Operator::kNoProperties, 1, 1)        \
  V(DoubleArrayMin, Operator::kNoProperties, 1, 1)

Definition at line 932 of file simplified-operator.cc.

◆ GET_FROM_CACHE

#define GET_FROM_CACHE	(		Name,
			... )

Value:

const Operator* SimplifiedOperatorBuilder::Name() { return &cache_.k##Name; }

Definition at line 1459 of file simplified-operator.cc.

◆ GET_FROM_CACHE_WITH_FEEDBACK [1/2]

#define GET_FROM_CACHE_WITH_FEEDBACK ( Name )

Value:

  const Operator* SimplifiedOperatorBuilder::Name(                     \
      const FeedbackSource& feedback, CheckBoundsFlags flags) {        \
    DCHECK(!(flags & CheckBoundsFlag::kConvertStringAndMinusZero));    \
    if (!feedback.IsValid()) {                                         \
      if (flags & CheckBoundsFlag::kAbortOnOutOfBounds) {              \
        return &cache_.k##Name##Aborting;                              \
      } else {                                                         \
        return &cache_.k##Name;                                        \
      }                                                                \
    }                                                                  \
    return zone()->New<SimplifiedOperatorGlobalCache::Name##Operator>( \
        feedback, flags);                                              \
  }

Definition at line 1478 of file simplified-operator.cc.

◆ GET_FROM_CACHE_WITH_FEEDBACK [2/2]

#define GET_FROM_CACHE_WITH_FEEDBACK	(	Name,
		value_input_count,
		value_output_count )

Value:

  const Operator* SimplifiedOperatorBuilder::Name(                          \
      const FeedbackSource& feedback) {                                     \
    if (!feedback.IsValid()) {                                              \
      return &cache_.k##Name;                                               \
    }                                                                       \
    return zone()->New<Operator1<CheckParameters>>(                         \
        IrOpcode::k##Name, Operator::kFoldable | Operator::kNoThrow, #Name, \
        value_input_count, 1, 1, value_output_count, 1, 0,                  \
        CheckParameters(feedback));                                         \
  }

Definition at line 1478 of file simplified-operator.cc.

◆ MAKE_OR

#define MAKE_OR	(	name,
		arg2,
		arg3 )

Value:

op->opcode() == IrOpcode::k##name ||

◆ PURE

#define PURE	(	Name,
		properties,
		value_input_count,
		control_input_count )

Value:

  struct Name##Operator final : public Operator {                          \
    Name##Operator()                                                       \
        : Operator(IrOpcode::k##Name, Operator::kPure | properties, #Name, \
                   value_input_count, 0, control_input_count, 1, 0, 0) {}  \
  };                                                                       \
  Name##Operator k##Name;

Definition at line 1006 of file simplified-operator.cc.

◆ PURE_OP_LIST

#define PURE_OP_LIST ( V )

Definition at line 801 of file simplified-operator.cc.

◆ SPECULATIVE_BIGINT_BINOP

#define SPECULATIVE_BIGINT_BINOP ( Name )

Value:

  const Operator* SimplifiedOperatorBuilder::Name(BigIntOperationHint hint) {  \
    return zone()->New<Operator1<BigIntOperationHint>>(                        \
        IrOpcode::k##Name, Operator::kFoldable | Operator::kNoThrow, #Name, 2, \
        1, 1, 1, 1, 0, hint);                                                  \
  }

Definition at line 1981 of file simplified-operator.cc.

◆ SPECULATIVE_NUMBER_BINOP [1/2]

#define SPECULATIVE_NUMBER_BINOP ( Name )

Value:

  template <NumberOperationHint kHint>                                     \
  struct Name##Operator final : public Operator1<NumberOperationHint> {    \
    Name##Operator()                                                       \
        : Operator1<NumberOperationHint>(                                  \
              IrOpcode::k##Name, Operator::kFoldable | Operator::kNoThrow, \
              #Name, 2, 1, 1, 1, 1, 0, kHint) {}                           \
  };                                                                       \
  Name##Operator<NumberOperationHint::kSignedSmall>                        \
      k##Name##SignedSmallOperator;                                        \
  Name##Operator<NumberOperationHint::kSignedSmallInputs>                  \
      k##Name##SignedSmallInputsOperator;                                  \
  Name##Operator<NumberOperationHint::kAdditiveSafeInteger>                \
      k##Name##SafeIntOperator;                                            \
  Name##Operator<NumberOperationHint::kNumber> k##Name##NumberOperator;    \
  Name##Operator<NumberOperationHint::kNumberOrOddball>                    \
      k##Name##NumberOrOddballOperator;

Definition at line 1376 of file simplified-operator.cc.

◆ SPECULATIVE_NUMBER_BINOP [2/2]

#define SPECULATIVE_NUMBER_BINOP ( Name )

Value:

  const Operator* SimplifiedOperatorBuilder::Name(NumberOperationHint hint) { \
    switch (hint) {                                                           \
      case NumberOperationHint::kSignedSmall:                                 \
        return &cache_.k##Name##SignedSmallOperator;                          \
      case NumberOperationHint::kSignedSmallInputs:                           \
        return &cache_.k##Name##SignedSmallInputsOperator;                    \
      case NumberOperationHint::kAdditiveSafeInteger:                         \
        return &cache_.k##Name##SafeIntOperator;                              \
      case NumberOperationHint::kNumber:                                      \
        return &cache_.k##Name##NumberOperator;                               \
      case NumberOperationHint::kNumberOrBoolean:                             \
        /* Not used currenly. */                                              \
        UNREACHABLE();                                                        \
      case NumberOperationHint::kNumberOrOddball:                             \
        return &cache_.k##Name##NumberOrOddballOperator;                      \
    }                                                                         \
    UNREACHABLE();                                                            \
    return nullptr;                                                           \
  }

Definition at line 1376 of file simplified-operator.cc.

◆ SPECULATIVE_NUMBER_BINOP_LIST

#define SPECULATIVE_NUMBER_BINOP_LIST ( V )

Value:

  SIMPLIFIED_SPECULATIVE_NUMBER_BINOP_LIST(V) \
  V(SpeculativeNumberEqual)                   \
  V(SpeculativeNumberLessThan)                \
  V(SpeculativeNumberLessThanOrEqual)

Definition at line 951 of file simplified-operator.cc.

Variable Documentation

◆ double_map_

MapRef const double_map_

private

Definition at line 434 of file simplified-operator.cc.

◆ fast_map_

MapRef const fast_map_

private

Definition at line 435 of file simplified-operator.cc.

◆ value_type_

Type value_type_

private

Definition at line 473 of file simplified-operator.cc.

Classes

Namespaces

Macros

Functions

Macro Definition Documentation

◆ ACCESS

◆ ACCESS_OP_LIST

◆ CASE

◆ CHECK_IF [1/2]

◆ CHECK_IF [2/2]

◆ CHECKED

◆ CHECKED_BOUNDS

◆ CHECKED_BOUNDS_OP_LIST

◆ CHECKED_OP_LIST

◆ CHECKED_WITH_FEEDBACK

◆ CHECKED_WITH_FEEDBACK_OP_LIST

◆ EFFECT_DEPENDENT

◆ EFFECT_DEPENDENT_OP_LIST

◆ GET_FROM_CACHE

◆ GET_FROM_CACHE_WITH_FEEDBACK [1/2]

◆ GET_FROM_CACHE_WITH_FEEDBACK [2/2]

◆ MAKE_OR

◆ PURE

◆ PURE_OP_LIST

◆ SPECULATIVE_BIGINT_BINOP

◆ SPECULATIVE_NUMBER_BINOP [1/2]

◆ SPECULATIVE_NUMBER_BINOP [2/2]

◆ SPECULATIVE_NUMBER_BINOP_LIST

Variable Documentation

◆ double_map_

◆ fast_map_

◆ value_type_