#include "src/compiler/common-operator.h"
#include <optional>
#include "src/base/hashing.h"
#include "src/base/lazy-instance.h"
#include "src/compiler/linkage.h"
#include "src/compiler/node.h"
#include "src/compiler/opcodes.h"
#include "src/compiler/operator.h"
#include "src/handles/handles-inl.h"
#include "src/zone/zone.h"

Include dependency graph for common-operator.cc:

Classes
struct	v8::internal::compiler::CommonOperatorGlobalCache

struct	v8::internal::compiler::CommonOperatorGlobalCache::EndOperator< kInputCount >

struct	v8::internal::compiler::CommonOperatorGlobalCache::ReturnOperator< kValueInputCount >

struct	v8::internal::compiler::CommonOperatorGlobalCache::BranchOperator< semantics, hint >

struct	v8::internal::compiler::CommonOperatorGlobalCache::EffectPhiOperator< kEffectInputCount >

struct	v8::internal::compiler::CommonOperatorGlobalCache::BeginRegionOperator< kRegionObservability >

struct	v8::internal::compiler::CommonOperatorGlobalCache::LoopOperator< kInputCount >

struct	v8::internal::compiler::CommonOperatorGlobalCache::MergeOperator< kInputCount >

struct	v8::internal::compiler::CommonOperatorGlobalCache::LoopExitValueOperator< kRep >

struct	v8::internal::compiler::CommonOperatorGlobalCache::DeoptimizeOperator< kReason >

struct	v8::internal::compiler::CommonOperatorGlobalCache::DeoptimizeIfOperator< kReason >

struct	v8::internal::compiler::CommonOperatorGlobalCache::DeoptimizeUnlessOperator< kReason >

struct	v8::internal::compiler::CommonOperatorGlobalCache::PhiOperator< kRep, kInputCount >

struct	v8::internal::compiler::CommonOperatorGlobalCache::InductionVariablePhiOperator< kInputCount >

struct	v8::internal::compiler::CommonOperatorGlobalCache::ParameterOperator< kIndex >

struct	v8::internal::compiler::CommonOperatorGlobalCache::ProjectionOperator< kIndex >

struct	v8::internal::compiler::CommonOperatorGlobalCache::StateValuesOperator< kInputCount >

Namespaces
namespace	v8

namespace	v8::internal

namespace	v8::internal::compiler

Macros
#define	COMMON_CACHED_OP_LIST(V)

#define	CACHED_LOOP_EXIT_VALUE_LIST(V)

#define	CACHED_BRANCH_LIST(V)

#define	CACHED_RETURN_LIST(V)

#define	CACHED_END_LIST(V)

#define	CACHED_EFFECT_PHI_LIST(V)

#define	CACHED_INDUCTION_VARIABLE_PHI_LIST(V)

#define	CACHED_LOOP_LIST(V)

#define	CACHED_MERGE_LIST(V)

#define	CACHED_DEOPTIMIZE_LIST(V)

#define	CACHED_DEOPTIMIZE_IF_LIST(V)

#define	CACHED_DEOPTIMIZE_UNLESS_LIST(V)

#define	CACHED_TRAP_IF_LIST(V)

#define	CACHED_TRAP_UNLESS_LIST(V)

#define	CACHED_PARAMETER_LIST(V)

#define	CACHED_PHI_LIST(V)

#define	CACHED_PROJECTION_LIST(V)

#define	CACHED_STATE_VALUES_LIST(V)

#define	CACHED(Name, properties, value_input_count, effect_input_count, control_input_count, value_output_count, effect_output_count, control_output_count)

#define	CACHED_END(input_count)

#define	CACHED_RETURN(value_input_count)

#define	CACHED_BRANCH(Semantics, Hint)

#define	CACHED_EFFECT_PHI(input_count)

#define	CACHED_LOOP(input_count)

#define	CACHED_MERGE(input_count)

#define	CACHED_LOOP_EXIT_VALUE(rep)

#define	CACHED_DEOPTIMIZE(Reason)

#define	CACHED_DEOPTIMIZE_IF(Reason)

#define	CACHED_DEOPTIMIZE_UNLESS(Reason)

#define	CACHED_PHI(rep, input_count)

#define	CACHED_INDUCTION_VARIABLE_PHI(input_count)

#define	CACHED_PARAMETER(index)

#define	CACHED_PROJECTION(index)

#define	CACHED_STATE_VALUES(input_count)

#define	CACHED(Name, properties, value_input_count, effect_input_count, control_input_count, value_output_count, effect_output_count, control_output_count)

#define	CACHED_END(input_count)

#define	CACHED_RETURN(input_count)

#define	CACHED_BRANCH(Semantics, Hint)

#define	CACHED_DEOPTIMIZE(Reason)

#define	CACHED_DEOPTIMIZE_IF(Reason)

#define	CACHED_DEOPTIMIZE_UNLESS(Reason)

#define	CACHED_LOOP(input_count)

#define	CACHED_MERGE(input_count)

#define	CACHED_LOOP_EXIT_VALUE(kRep)

#define	CACHED_PARAMETER(index)

#define	CACHED_PHI(kRep, kValueInputCount)

#define	CACHED_EFFECT_PHI(input_count)

#define	CACHED_INDUCTION_VARIABLE_PHI(input_count)

#define	CACHED_STATE_VALUES(arguments)

#define	CACHED_PROJECTION(index)

Functions
std::ostream &	v8::internal::operator<< (std::ostream &os, BranchHint hint)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, BranchSemantics semantics)

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

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

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

const BranchParameters &	v8::internal::compiler::BranchParametersOf (const Operator *const op)

BranchHint	v8::internal::compiler::BranchHintOf (const Operator *const op)

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

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

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

const AssertParameters &	v8::internal::compiler::AssertParametersOf (const Operator *const op)

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

bool	v8::internal::compiler::operator== (DeoptimizeParameters lhs, DeoptimizeParameters rhs)

bool	v8::internal::compiler::operator!= (DeoptimizeParameters lhs, DeoptimizeParameters rhs)

size_t	v8::internal::compiler::hash_value (DeoptimizeParameters p)

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

DeoptimizeParameters const &	v8::internal::compiler::DeoptimizeParametersOf (Operator const *const op)

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

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

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

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

SelectParameters const &	v8::internal::compiler::SelectParametersOf (const Operator *const op)

CallDescriptor const *	v8::internal::compiler::CallDescriptorOf (const Operator *const op)

size_t	v8::internal::compiler::ProjectionIndexOf (const Operator *const op)

MachineRepresentation	v8::internal::compiler::PhiRepresentationOf (const Operator *const op)

MachineRepresentation	v8::internal::compiler::LoopExitValueRepresentationOf (const Operator *const op)

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

const ParameterInfo &	v8::internal::compiler::ParameterInfoOf (const Operator *const op)

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

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

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

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, ParameterInfo const &i)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, ObjectStateInfo const &i)

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

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, TypedObjectStateInfo const &i)

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

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

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

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

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

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

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

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

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

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

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

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

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

size_t	v8::internal::compiler::hash_value (RegionObservability observability)

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, RegionObservability observability)

RegionObservability	v8::internal::compiler::RegionObservabilityOf (Operator const *op)

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

std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, const ZoneVector< MachineType > *types)

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

SparseInputMask	v8::internal::compiler::SparseInputMaskOf (Operator const *op)

ZoneVector< MachineType > const *	v8::internal::compiler::MachineTypesOf (Operator const *op)

V8_EXPORT_PRIVATE bool	v8::internal::compiler::operator== (IfValueParameters const &l, IfValueParameters const &r)

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

V8_EXPORT_PRIVATE std::ostream &	v8::internal::compiler::operator<< (std::ostream &out, IfValueParameters const &p)

IfValueParameters const &	v8::internal::compiler::IfValueParametersOf (const Operator *op)

V8_EXPORT_PRIVATE bool	v8::internal::compiler::operator== (const SLVerifierHintParameters &p1, const SLVerifierHintParameters &p2)

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

V8_EXPORT_PRIVATE std::ostream &	v8::internal::compiler::operator<< (std::ostream &out, const SLVerifierHintParameters &p)

const SLVerifierHintParameters &	v8::internal::compiler::SLVerifierHintParametersOf (const Operator *op)

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

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

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

const ExitMachineGraphParameters &	v8::internal::compiler::ExitMachineGraphParametersOf (const Operator *op)

Handle< HeapObject >	v8::internal::compiler::HeapConstantOf (const Operator *op)

const char *	v8::internal::compiler::StaticAssertSourceOf (const Operator *op)

ArgumentsStateType	v8::internal::compiler::ArgumentsStateTypeOf (Operator const *op)

uint32_t	v8::internal::compiler::ObjectIdOf (Operator const *op)

MachineRepresentation	v8::internal::compiler::DeadValueRepresentationOf (Operator const *op)

const FrameStateInfo &	v8::internal::compiler::FrameStateInfoOf (const Operator *op)

Macro Definition Documentation

◆ CACHED [1/2]

#define CACHED	(	Name,
		properties,
		value_input_count,
		effect_input_count,
		control_input_count,
		value_output_count,
		effect_output_count,
		control_output_count )

Value:

  struct Name##Operator final : public Operator {                            \
    Name##Operator()                                                         \
        : Operator(IrOpcode::k##Name, properties, #Name, value_input_count,  \
                   effect_input_count, control_input_count,                  \
                   value_output_count, effect_output_count,                  \
                   control_output_count) {}                                  \
  };                                                                         \
  Name##Operator k##Name##Operator;

Definition at line 676 of file common-operator.cc.

◆ CACHED [2/2]

#define CACHED	(	Name,
		properties,
		value_input_count,
		effect_input_count,
		control_input_count,
		value_output_count,
		effect_output_count,
		control_output_count )

Value:

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

Definition at line 676 of file common-operator.cc.

◆ CACHED_BRANCH [1/2]

#define CACHED_BRANCH	(		Semantics,
			Hint )

Value:

BranchOperator<BranchSemantics::k##Semantics, BranchHint::k##Hint> \

kBranch##Semantics##Hint##Operator;

Definition at line 725 of file common-operator.cc.

◆ CACHED_BRANCH [2/2]

#define CACHED_BRANCH	(		Semantics,
			Hint )

Value:

  if (semantics == BranchSemantics::k##Semantics &&    \
      hint == BranchHint::k##Hint) {                   \
    return &cache_.kBranch##Semantics##Hint##Operator; \
  }

Definition at line 725 of file common-operator.cc.

◆ CACHED_BRANCH_LIST

#define CACHED_BRANCH_LIST ( V )

Value:

  V(JS, None)                 \
  V(JS, True)                 \
  V(JS, False)                \
  V(Machine, None)            \
  V(Machine, True)            \
  V(Machine, False)           \
  V(Unspecified, None)        \
  V(Unspecified, True)        \
  V(Unspecified, False)

Definition at line 536 of file common-operator.cc.

◆ CACHED_DEOPTIMIZE [1/2]

#define CACHED_DEOPTIMIZE ( Reason )

Value:

DeoptimizeOperator<DeoptimizeReason::k##Reason> kDeoptimize##Reason##Operator;

Definition at line 807 of file common-operator.cc.

◆ CACHED_DEOPTIMIZE [2/2]

#define CACHED_DEOPTIMIZE ( Reason )

Value:

  if (reason == DeoptimizeReason::k##Reason && !feedback.IsValid()) { \
    return &cache_.kDeoptimize##Reason##Operator;                     \
  }

Definition at line 807 of file common-operator.cc.

◆ CACHED_DEOPTIMIZE_IF [1/2]

#define CACHED_DEOPTIMIZE_IF ( Reason )

Value:

DeoptimizeIfOperator<DeoptimizeReason::k##Reason> \

kDeoptimizeIf##Reason##Operator;

Definition at line 822 of file common-operator.cc.

◆ CACHED_DEOPTIMIZE_IF [2/2]

#define CACHED_DEOPTIMIZE_IF ( Reason )

Value:

  if (reason == DeoptimizeReason::k##Reason && !feedback.IsValid()) { \
    return &cache_.kDeoptimizeIf##Reason##Operator;                   \
  }

Definition at line 822 of file common-operator.cc.

◆ CACHED_DEOPTIMIZE_IF_LIST

#define CACHED_DEOPTIMIZE_IF_LIST ( V )

Value:

  V(DivisionByZero)                  \
  V(Hole)                            \
  V(MinusZero)                       \
  V(Overflow)                        \
  V(Smi)

Definition at line 599 of file common-operator.cc.

◆ CACHED_DEOPTIMIZE_LIST

#define CACHED_DEOPTIMIZE_LIST ( V )

Value:

  V(MinusZero)                                     \
  V(WrongMap)                                      \
  V(InsufficientTypeFeedbackForGenericKeyedAccess) \
  V(InsufficientTypeFeedbackForGenericNamedAccess)

Definition at line 593 of file common-operator.cc.

◆ CACHED_DEOPTIMIZE_UNLESS [1/2]

#define CACHED_DEOPTIMIZE_UNLESS ( Reason )

Value:

DeoptimizeUnlessOperator<DeoptimizeReason::k##Reason> \

kDeoptimizeUnless##Reason##Operator;

Definition at line 839 of file common-operator.cc.

◆ CACHED_DEOPTIMIZE_UNLESS [2/2]

#define CACHED_DEOPTIMIZE_UNLESS ( Reason )

Value:

  if (reason == DeoptimizeReason::k##Reason && !feedback.IsValid()) { \
    return &cache_.kDeoptimizeUnless##Reason##Operator;               \
  }

Definition at line 839 of file common-operator.cc.

◆ CACHED_DEOPTIMIZE_UNLESS_LIST

#define CACHED_DEOPTIMIZE_UNLESS_LIST ( V )

Value:

  V(LostPrecision)                       \
  V(LostPrecisionOrNaN)                  \
  V(NotAHeapNumber)                      \
  V(NotANumberOrOddball)                 \
  V(NotASmi)                             \
  V(OutOfBounds)                         \
  V(WrongInstanceType)                   \
  V(WrongMap)

Definition at line 606 of file common-operator.cc.

◆ CACHED_EFFECT_PHI [1/2]

#define CACHED_EFFECT_PHI ( input_count )

Value:

EffectPhiOperator<input_count> kEffectPhi##input_count##Operator;

Definition at line 739 of file common-operator.cc.

◆ CACHED_EFFECT_PHI [2/2]

#define CACHED_EFFECT_PHI ( input_count )

Value:

case input_count: \

return &cache_.kEffectPhi##input_count##Operator;

Definition at line 739 of file common-operator.cc.

◆ CACHED_EFFECT_PHI_LIST

#define CACHED_EFFECT_PHI_LIST ( V )

Value:

  V(1)                            \
  V(2)                            \
  V(3)                            \
  V(4)                            \
  V(5)                            \
  V(6)

Definition at line 564 of file common-operator.cc.

◆ CACHED_END [1/2]

#define CACHED_END ( input_count )

Value:

EndOperator<input_count> kEnd##input_count##Operator;

Definition at line 698 of file common-operator.cc.

◆ CACHED_END [2/2]

#define CACHED_END ( input_count )

Value:

case input_count: \

return &cache_.kEnd##input_count##Operator;

Definition at line 698 of file common-operator.cc.

◆ CACHED_END_LIST

#define CACHED_END_LIST ( V )

Value:

  V(1)                     \
  V(2)                     \
  V(3)                     \
  V(4)                     \
  V(5)                     \
  V(6)                     \
  V(7)                     \
  V(8)

Definition at line 553 of file common-operator.cc.

◆ CACHED_INDUCTION_VARIABLE_PHI [1/2]

#define CACHED_INDUCTION_VARIABLE_PHI ( input_count )

Value:

InductionVariablePhiOperator<input_count> \

kInductionVariablePhi##input_count##Operator;

Definition at line 914 of file common-operator.cc.

◆ CACHED_INDUCTION_VARIABLE_PHI [2/2]

#define CACHED_INDUCTION_VARIABLE_PHI ( input_count )

Value:

case input_count: \

return &cache_.kInductionVariablePhi##input_count##Operator;

Definition at line 914 of file common-operator.cc.

◆ CACHED_INDUCTION_VARIABLE_PHI_LIST

#define CACHED_INDUCTION_VARIABLE_PHI_LIST ( V )

Value:

  V(4)                                        \
  V(5)                                        \
  V(6)                                        \
  V(7)

Definition at line 572 of file common-operator.cc.

◆ CACHED_LOOP [1/2]

#define CACHED_LOOP ( input_count )

Value:

LoopOperator<input_count> kLoop##input_count##Operator;

Definition at line 766 of file common-operator.cc.

◆ CACHED_LOOP [2/2]

#define CACHED_LOOP ( input_count )

Value:

case input_count: \

return &cache_.kLoop##input_count##Operator;

Definition at line 766 of file common-operator.cc.

◆ CACHED_LOOP_EXIT_VALUE [1/2]

#define CACHED_LOOP_EXIT_VALUE ( kRep )

Value:

case MachineRepresentation::kRep: \

return &cache_.kLoopExitValue##kRep##Operator;

Definition at line 791 of file common-operator.cc.

◆ CACHED_LOOP_EXIT_VALUE [2/2]

#define CACHED_LOOP_EXIT_VALUE ( rep )

Value:

LoopExitValueOperator<MachineRepresentation::rep> \

kLoopExitValue##rep##Operator;

Definition at line 791 of file common-operator.cc.

◆ CACHED_LOOP_EXIT_VALUE_LIST

#define CACHED_LOOP_EXIT_VALUE_LIST ( V )

Value:

V(kTagged)

Definition at line 534 of file common-operator.cc.

◆ CACHED_LOOP_LIST

#define CACHED_LOOP_LIST ( V )

Value:

V(1) \

V(2)

Definition at line 578 of file common-operator.cc.

◆ CACHED_MERGE [1/2]

#define CACHED_MERGE ( input_count )

Value:

MergeOperator<input_count> kMerge##input_count##Operator;

Definition at line 779 of file common-operator.cc.

◆ CACHED_MERGE [2/2]

#define CACHED_MERGE ( input_count )

Value:

case input_count: \

return &cache_.kMerge##input_count##Operator;

Definition at line 779 of file common-operator.cc.

◆ CACHED_MERGE_LIST

#define CACHED_MERGE_LIST ( V )

Value:

  V(1)                       \
  V(2)                       \
  V(3)                       \
  V(4)                       \
  V(5)                       \
  V(6)                       \
  V(7)                       \
  V(8)

Definition at line 583 of file common-operator.cc.

◆ CACHED_PARAMETER [1/2]

#define CACHED_PARAMETER ( index )

Value:

ParameterOperator<index> kParameter##index##Operator;

Definition at line 929 of file common-operator.cc.

◆ CACHED_PARAMETER [2/2]

#define CACHED_PARAMETER ( index )

Value:

case index: \

return &cache_.kParameter##index##Operator;

index

OptionalOpIndex index

Definition instruction-selector-ia32.cc:66

Definition at line 929 of file common-operator.cc.

◆ CACHED_PARAMETER_LIST

#define CACHED_PARAMETER_LIST ( V )

Value:

  V(0)                           \
  V(1)                           \
  V(2)                           \
  V(3)                           \
  V(4)                           \
  V(5)                           \
  V(6)

Definition at line 631 of file common-operator.cc.

◆ CACHED_PHI [1/2]

#define CACHED_PHI	(		kRep,
			kValueInputCount )

Value:

  if (MachineRepresentation::kRep == rep &&                \
      kValueInputCount == value_input_count) {             \
    return &cache_.kPhi##kRep##kValueInputCount##Operator; \
  }

Definition at line 900 of file common-operator.cc.

◆ CACHED_PHI [2/2]

#define CACHED_PHI	(		rep,
			input_count )

Value:

PhiOperator<MachineRepresentation::rep, input_count> \

kPhi##rep##input_count##Operator;

Definition at line 900 of file common-operator.cc.

◆ CACHED_PHI_LIST

#define CACHED_PHI_LIST ( V )

Value:

  V(kTagged, 1)            \
  V(kTagged, 2)            \
  V(kTagged, 3)            \
  V(kTagged, 4)            \
  V(kTagged, 5)            \
  V(kTagged, 6)            \
  V(kBit, 2)               \
  V(kFloat64, 2)           \
  V(kWord32, 2)

Definition at line 641 of file common-operator.cc.

◆ CACHED_PROJECTION [1/2]

#define CACHED_PROJECTION ( index )

Value:

ProjectionOperator<index> kProjection##index##Operator;

Definition at line 944 of file common-operator.cc.

◆ CACHED_PROJECTION [2/2]

#define CACHED_PROJECTION ( index )

Value:

case index: \

return &cache_.kProjection##index##Operator;

Definition at line 944 of file common-operator.cc.

◆ CACHED_PROJECTION_LIST

#define CACHED_PROJECTION_LIST ( V )

Value:

V(0) \

V(1)

Definition at line 653 of file common-operator.cc.

◆ CACHED_RETURN [1/2]

#define CACHED_RETURN ( input_count )

Value:

case input_count: \

return &cache_.kReturn##input_count##Operator;

Definition at line 711 of file common-operator.cc.

◆ CACHED_RETURN [2/2]

#define CACHED_RETURN ( value_input_count )

Value:

ReturnOperator<value_input_count> kReturn##value_input_count##Operator;

Definition at line 711 of file common-operator.cc.

◆ CACHED_RETURN_LIST

#define CACHED_RETURN_LIST ( V )

Value:

  V(1)                        \
  V(2)                        \
  V(3)                        \
  V(4)

Definition at line 547 of file common-operator.cc.

◆ CACHED_STATE_VALUES [1/2]

#define CACHED_STATE_VALUES ( arguments )

Value:

case arguments: \

return &cache_.kStateValues##arguments##Operator;

Definition at line 959 of file common-operator.cc.

◆ CACHED_STATE_VALUES [2/2]

#define CACHED_STATE_VALUES ( input_count )

Value:

StateValuesOperator<input_count> kStateValues##input_count##Operator;

Definition at line 959 of file common-operator.cc.

◆ CACHED_STATE_VALUES_LIST

#define CACHED_STATE_VALUES_LIST ( V )

Value:

  V(0)                              \
  V(1)                              \
  V(2)                              \
  V(3)                              \
  V(4)                              \
  V(5)                              \
  V(6)                              \
  V(7)                              \
  V(8)                              \
  V(10)                             \
  V(11)                             \
  V(12)                             \
  V(13)                             \
  V(14)

Definition at line 658 of file common-operator.cc.

◆ CACHED_TRAP_IF_LIST

#define CACHED_TRAP_IF_LIST ( V )

Value:

V(TrapDivUnrepresentable) \

V(TrapFloatUnrepresentable)

Definition at line 616 of file common-operator.cc.

◆ CACHED_TRAP_UNLESS_LIST

#define CACHED_TRAP_UNLESS_LIST ( V )

Value:

  V(TrapUnreachable)               \
  V(TrapMemOutOfBounds)            \
  V(TrapDivByZero)                 \
  V(TrapDivUnrepresentable)        \
  V(TrapRemByZero)                 \
  V(TrapFloatUnrepresentable)      \
  V(TrapTableOutOfBounds)          \
  V(TrapFuncSigMismatch)

Definition at line 621 of file common-operator.cc.

◆ COMMON_CACHED_OP_LIST

#define COMMON_CACHED_OP_LIST ( V )

Value:

  V(Plug, Operator::kNoProperties, 0, 0, 0, 1, 0, 0)      \
  V(Dead, Operator::kFoldable, 0, 0, 0, 1, 1, 1)          \
  V(Unreachable, Operator::kFoldable, 0, 1, 1, 1, 1, 0)   \
  V(IfTrue, Operator::kKontrol, 0, 0, 1, 0, 0, 1)         \
  V(IfFalse, Operator::kKontrol, 0, 0, 1, 0, 0, 1)        \
  V(IfSuccess, Operator::kKontrol, 0, 0, 1, 0, 0, 1)      \
  V(IfException, Operator::kKontrol, 0, 1, 1, 1, 1, 1)    \
  V(Throw, Operator::kKontrol, 0, 1, 1, 0, 0, 1)          \
  V(Terminate, Operator::kKontrol, 0, 1, 1, 0, 0, 1)      \
  V(LoopExit, Operator::kKontrol, 0, 0, 2, 0, 0, 1)       \
  V(LoopExitEffect, Operator::kNoThrow, 0, 1, 1, 0, 1, 0) \
  V(Checkpoint, Operator::kKontrol, 0, 1, 1, 0, 1, 0)     \
  V(FinishRegion, Operator::kKontrol, 1, 1, 0, 1, 1, 0)   \
  V(Retain, Operator::kKontrol, 1, 1, 0, 0, 1, 0)

Definition at line 518 of file common-operator.cc.

Classes

Namespaces

Macros

Functions

Macro Definition Documentation

◆ CACHED [1/2]

◆ CACHED [2/2]

◆ CACHED_BRANCH [1/2]

◆ CACHED_BRANCH [2/2]

◆ CACHED_BRANCH_LIST

◆ CACHED_DEOPTIMIZE [1/2]

◆ CACHED_DEOPTIMIZE [2/2]

◆ CACHED_DEOPTIMIZE_IF [1/2]

◆ CACHED_DEOPTIMIZE_IF [2/2]

◆ CACHED_DEOPTIMIZE_IF_LIST

◆ CACHED_DEOPTIMIZE_LIST

◆ CACHED_DEOPTIMIZE_UNLESS [1/2]

◆ CACHED_DEOPTIMIZE_UNLESS [2/2]

◆ CACHED_DEOPTIMIZE_UNLESS_LIST

◆ CACHED_EFFECT_PHI [1/2]

◆ CACHED_EFFECT_PHI [2/2]

◆ CACHED_EFFECT_PHI_LIST

◆ CACHED_END [1/2]

◆ CACHED_END [2/2]

◆ CACHED_END_LIST

◆ CACHED_INDUCTION_VARIABLE_PHI [1/2]

◆ CACHED_INDUCTION_VARIABLE_PHI [2/2]

◆ CACHED_INDUCTION_VARIABLE_PHI_LIST

◆ CACHED_LOOP [1/2]

◆ CACHED_LOOP [2/2]

◆ CACHED_LOOP_EXIT_VALUE [1/2]

◆ CACHED_LOOP_EXIT_VALUE [2/2]

◆ CACHED_LOOP_EXIT_VALUE_LIST

◆ CACHED_LOOP_LIST

◆ CACHED_MERGE [1/2]

◆ CACHED_MERGE [2/2]

◆ CACHED_MERGE_LIST

◆ CACHED_PARAMETER [1/2]

◆ CACHED_PARAMETER [2/2]

◆ CACHED_PARAMETER_LIST

◆ CACHED_PHI [1/2]

◆ CACHED_PHI [2/2]

◆ CACHED_PHI_LIST

◆ CACHED_PROJECTION [1/2]

◆ CACHED_PROJECTION [2/2]

◆ CACHED_PROJECTION_LIST

◆ CACHED_RETURN [1/2]

◆ CACHED_RETURN [2/2]

◆ CACHED_RETURN_LIST

◆ CACHED_STATE_VALUES [1/2]

◆ CACHED_STATE_VALUES [2/2]

◆ CACHED_STATE_VALUES_LIST

◆ CACHED_TRAP_IF_LIST

◆ CACHED_TRAP_UNLESS_LIST

◆ COMMON_CACHED_OP_LIST