machine-operator.cc File Reference

#include "src/compiler/machine-operator.h"
#include <optional>
#include "src/base/lazy-instance.h"
#include "src/compiler/opcodes.h"
#include "src/compiler/operator.h"

Include dependency graph for machine-operator.cc:

Go to the source code of this file.

Classes
struct	v8::internal::compiler::StackSlotOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache
struct	v8::internal::compiler::MachineOperatorGlobalCache::NormalWord32SarOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache::ShiftOutZerosWord32SarOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache::NormalWord64SarOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache::ShiftOutZerosWord64SarOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache::ArchitectureDefaultTruncateFloat32ToUint32Operator
struct	v8::internal::compiler::MachineOperatorGlobalCache::SetOverflowToMinTruncateFloat32ToUint32Operator
struct	v8::internal::compiler::MachineOperatorGlobalCache::ArchitectureDefaultTruncateFloat32ToInt32Operator
struct	v8::internal::compiler::MachineOperatorGlobalCache::SetOverflowToMinTruncateFloat32ToInt32Operator
struct	v8::internal::compiler::MachineOperatorGlobalCache::ArchitectureDefaultTruncateFloat64ToInt64Operator
struct	v8::internal::compiler::MachineOperatorGlobalCache::SetOverflowToMinTruncateFloat64ToInt64Operator
struct	v8::internal::compiler::MachineOperatorGlobalCache::TruncateFloat64ToFloat16RawBitsOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache::ChangeFloat16RawBitsToFloat64
struct	v8::internal::compiler::MachineOperatorGlobalCache::StoreIndirectPointerOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache::StoreIndirectPointerNoWriteBarrierOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache::StoreIndirectPointerWithIndirectPointerWriteBarrierOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache::Word32SeqCstPairLoadOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache::Word32SeqCstPairStoreOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache::Word32AtomicPairCompareExchangeOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache::MemoryBarrierOperator< order >
struct	v8::internal::compiler::MachineOperatorGlobalCache::BitcastWordToTaggedOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache::BitcastTaggedToWordOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache::BitcastMaybeObjectToWordOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache::AbortCSADcheckOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache::DebugBreakOperator
struct	v8::internal::compiler::MachineOperatorGlobalCache::StackPointerGreaterThanOperator
struct	v8::internal::compiler::CommentOperator

Namespaces
namespace	v8
namespace	v8::internal
namespace	v8::internal::compiler

Macros
#define	PURE_BINARY_OP_LIST_32(V)
#define	PURE_BINARY_OP_LIST_64(V)
#define	PURE_SIMD_OP_LIST(V)
#define	MACHINE_PURE_OP_LIST(V)
#define	PURE_OPTIONAL_OP_LIST(V)
#define	OVERFLOW_OP_LIST(V)
#define	MACHINE_TYPE_LIST(V)
#define	MACHINE_REPRESENTATION_LIST(V)
#define	STORE_PAIR_MACHINE_REPRESENTATION_LIST(V)
#define	LOAD_TRANSFORM_LIST(V)
#define	ATOMIC_TAGGED_TYPE_LIST(V)
#define	ATOMIC64_TAGGED_TYPE_LIST(V)
#define	ATOMIC_U32_TYPE_LIST(V)
#define	ATOMIC_TYPE_LIST(V)
#define	ATOMIC_U64_TYPE_LIST(V)
#define	ATOMIC_TAGGED_REPRESENTATION_LIST(V)
#define	ATOMIC64_TAGGED_REPRESENTATION_LIST(V)
#define	ATOMIC_REPRESENTATION_LIST(V)
#define	ATOMIC64_REPRESENTATION_LIST(V)
#define	ATOMIC_PAIR_BINOP_LIST(V)
#define	SIMD_LANE_OP_LIST(V)
#define	SIMD_I64x2_LANES(V)
#define	SIMD_I32x4_LANES(V)
#define	SIMD_I16x8_LANES(V)
#define	SIMD_I8x16_LANES(V)
#define	STACK_SLOT_CACHED_SIZES_ALIGNMENTS_LIST(V)
#define	PURE(Name, properties, value_input_count, control_input_count, output_count)
#define	OVERFLOW_OP(Name, properties)
#define	LOAD(Type)
#define	STACKSLOT(Size, Alignment, IsTagged)
#define	STORE(Type)
#define	STORE_PAIR(Type1, Type2)
#define	ATOMIC_LOAD_WITH_KIND(Type, Kind)
#define	ATOMIC_LOAD(Type)
#define	ATOMIC_LOAD_WITH_KIND(Type, Kind)
#define	ATOMIC_LOAD(Type)
#define	ATOMIC_STORE_WITH_KIND(Type, Kind)
#define	ATOMIC_STORE(Type)
#define	ATOMIC_STORE_WITH_KIND(Type, Kind)
#define	ATOMIC_STORE(Type)
#define	ATOMIC_OP(op, type, kind)
#define	ATOMIC_OP_LIST_WITH_KIND(type, kind)
#define	ATOMIC_OP_LIST(type)
#define	ATOMIC64_OP_LIST_WITH_KIND(type, kind)
#define	ATOMIC64_OP_LIST(type)
#define	ATOMIC_COMPARE_EXCHANGE_WITH_KIND(Type, Kind)
#define	ATOMIC_COMPARE_EXCHANGE(Type)
#define	ATOMIC_COMPARE_EXCHANGE_WITH_KIND(Type, Kind)
#define	ATOMIC_COMPARE_EXCHANGE(Type)
#define	ATOMIC_PAIR_OP(op)
#define	STACK_POINTER_GREATER_THAN(Kind)
#define	LOAD(Type)
#define	STORE(kRep)
#define	PURE(Name, properties, value_input_count, control_input_count, output_count)
#define	PURE(Name, properties, value_input_count, control_input_count, output_count)
#define	OVERFLOW_OP(Name, properties)
#define	LOAD(Type)
#define	LOAD(Type)
#define	LOAD(Type)
#define	LOAD(Type)
#define	CASE_CACHED_SIZE(Size, Alignment, IsTagged)
#define	STORE(kRep)
#define	STORE(kRep1, kRep2)
#define	STORE(kRep)
#define	STORE(kRep)
#define	CACHED_LOAD_WITH_KIND(Type, Kind)
#define	CACHED_LOAD(Type)
#define	LOAD(Type)
#define	CACHED_STORE_WITH_KIND(kRep, Kind)
#define	CACHED_STORE(kRep)
#define	STORE(kRep)
#define	EXCHANGE_WITH_KIND(kType, Kind)
#define	EXCHANGE(kType)
#define	COMPARE_EXCHANGE_WITH_KIND(kType, Kind)
#define	COMPARE_EXCHANGE(kType)
#define	OP_WITH_KIND(kType, Kind)
#define	OP(kType)
#define	OP_WITH_KIND(kType, Kind)
#define	OP(kType)
#define	OP_WITH_KIND(kType, Kind)
#define	OP(kType)
#define	OP_WITH_KIND(kType, Kind)
#define	OP(kType)
#define	OP_WITH_KIND(kType, Kind)
#define	OP(kType)
#define	CACHED_LOAD_WITH_KIND(Type, Kind)
#define	CACHED_LOAD(Type)
#define	LOAD(Type)
#define	CACHED_STORE_WITH_KIND(kRep, Kind)
#define	CACHED_STORE(kRep)
#define	STORE(kRep)
#define	OP_WITH_KIND(kType, Kind)
#define	OP(kType)
#define	OP_WITH_KIND(kType, Kind)
#define	OP(kType)
#define	OP_WITH_KIND(kType, Kind)
#define	OP(kType)
#define	OP_WITH_KIND(kType, Kind)
#define	OP(kType)
#define	OP_WITH_KIND(kType, Kind)
#define	OP(kType)
#define	OP_WITH_KIND(kType, Kind)
#define	OP(kType)
#define	OP_WITH_KIND(kType, Kind)
#define	OP(kType)

Functions
bool	v8::internal::compiler::operator== (StoreRepresentation lhs, StoreRepresentation rhs)
bool	v8::internal::compiler::operator!= (StoreRepresentation lhs, StoreRepresentation rhs)
size_t	v8::internal::compiler::hash_value (StoreRepresentation rep)
std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, StoreRepresentation rep)
bool	v8::internal::compiler::operator== (AtomicStoreParameters lhs, AtomicStoreParameters rhs)
bool	v8::internal::compiler::operator!= (AtomicStoreParameters lhs, AtomicStoreParameters rhs)
size_t	v8::internal::compiler::hash_value (AtomicStoreParameters params)
std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, AtomicStoreParameters params)
bool	v8::internal::compiler::operator== (AtomicLoadParameters lhs, AtomicLoadParameters rhs)
bool	v8::internal::compiler::operator!= (AtomicLoadParameters lhs, AtomicLoadParameters rhs)
size_t	v8::internal::compiler::hash_value (AtomicLoadParameters params)
std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, AtomicLoadParameters params)
bool	v8::internal::compiler::operator== (AtomicOpParameters lhs, AtomicOpParameters rhs)
bool	v8::internal::compiler::operator!= (AtomicOpParameters lhs, AtomicOpParameters rhs)
size_t	v8::internal::compiler::hash_value (AtomicOpParameters params)
std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, AtomicOpParameters params)
size_t	v8::internal::compiler::hash_value (MemoryAccessKind)
V8_EXPORT_PRIVATE std::ostream &	v8::internal::compiler::operator<< (std::ostream &, MemoryAccessKind)
size_t	v8::internal::compiler::hash_value (LoadTransformation rep)
std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, LoadTransformation rep)
size_t	v8::internal::compiler::hash_value (LoadTransformParameters params)
std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, LoadTransformParameters params)
LoadRepresentation	v8::internal::compiler::LoadRepresentationOf (Operator const *op)
AtomicLoadParameters	v8::internal::compiler::AtomicLoadParametersOf (Operator const *op)
AtomicOpParameters	v8::internal::compiler::AtomicOpParametersOf (Operator const *op)
StoreRepresentation const &	v8::internal::compiler::StoreRepresentationOf (Operator const *op)
StorePairRepresentation const &	v8::internal::compiler::StorePairRepresentationOf (Operator const *op)
AtomicStoreParameters const &	v8::internal::compiler::AtomicStoreParametersOf (Operator const *op)
UnalignedStoreRepresentation const &	v8::internal::compiler::UnalignedStoreRepresentationOf (Operator const *op)
bool	v8::internal::compiler::operator== (StackSlotRepresentation lhs, StackSlotRepresentation rhs)
bool	v8::internal::compiler::operator!= (StackSlotRepresentation lhs, StackSlotRepresentation rhs)
size_t	v8::internal::compiler::hash_value (StackSlotRepresentation rep)
std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, StackSlotRepresentation rep)
StackSlotRepresentation const &	v8::internal::compiler::StackSlotRepresentationOf (Operator const *op)
MachineType	v8::internal::compiler::AtomicOpType (Operator const *op)
size_t	v8::internal::compiler::hash_value (ShiftKind kind)
V8_EXPORT_PRIVATE std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, ShiftKind kind)
ShiftKind	v8::internal::compiler::ShiftKindOf (Operator const *op)
size_t	v8::internal::compiler::hash_value (TruncateKind kind)
std::ostream &	v8::internal::compiler::operator<< (std::ostream &os, TruncateKind kind)
StackCheckKind	v8::internal::compiler::StackCheckKindOf (Operator const *op)

Macro Definition Documentation

ATOMIC64_OP_LIST

#define ATOMIC64_OP_LIST

(

type

)

Value:

  ATOMIC64_OP_LIST_WITH_KIND(type, Normal) \
  ATOMIC64_OP_LIST_WITH_KIND(type, ProtectedByTrapHandler)

Definition at line 1649 of file machine-operator.cc.

ATOMIC64_OP_LIST_WITH_KIND

#define ATOMIC64_OP_LIST_WITH_KIND	(		type,
			kind )

Value:

  ATOMIC_OP(Word64AtomicAdd, type, kind)       \
  ATOMIC_OP(Word64AtomicSub, type, kind)       \
  ATOMIC_OP(Word64AtomicAnd, type, kind)       \
  ATOMIC_OP(Word64AtomicOr, type, kind)        \
  ATOMIC_OP(Word64AtomicXor, type, kind)       \
  ATOMIC_OP(Word64AtomicExchange, type, kind)

Definition at line 1642 of file machine-operator.cc.

ATOMIC64_REPRESENTATION_LIST

#define ATOMIC64_REPRESENTATION_LIST

(

V

)

Value:

  ATOMIC_REPRESENTATION_LIST(V)         \
  V(kWord64)

Definition at line 1124 of file machine-operator.cc.

ATOMIC64_TAGGED_REPRESENTATION_LIST

#define ATOMIC64_TAGGED_REPRESENTATION_LIST

(

V

)

Definition at line 1115 of file machine-operator.cc.

ATOMIC64_TAGGED_TYPE_LIST

#define ATOMIC64_TAGGED_TYPE_LIST

(

V

)

Definition at line 1078 of file machine-operator.cc.

ATOMIC_COMPARE_EXCHANGE [1/2]

#define ATOMIC_COMPARE_EXCHANGE

(

Type

)

Value:

  ATOMIC_COMPARE_EXCHANGE_WITH_KIND(Type, Normal) \
  ATOMIC_COMPARE_EXCHANGE_WITH_KIND(Type, ProtectedByTrapHandler)

Definition at line 1672 of file machine-operator.cc.

ATOMIC_COMPARE_EXCHANGE [2/2]

#define ATOMIC_COMPARE_EXCHANGE

(

Type

)

Value:

  ATOMIC_COMPARE_EXCHANGE_WITH_KIND(Type, Normal) \
  ATOMIC_COMPARE_EXCHANGE_WITH_KIND(Type, ProtectedByTrapHandler)

Definition at line 1672 of file machine-operator.cc.

ATOMIC_COMPARE_EXCHANGE_WITH_KIND [1/2]

#define ATOMIC_COMPARE_EXCHANGE_WITH_KIND	(		Type,
			Kind )

Value:

  struct Word32AtomicCompareExchange##Type##Kind##Operator                     \
      : public Operator1<AtomicOpParameters> {                                 \
    Word32AtomicCompareExchange##Type##Kind##Operator()                        \
        : Operator1<AtomicOpParameters>(                                       \
                                 IrOpcode::kWord32AtomicCompareExchange,       \
                                 Operator::kNoDeopt | Operator::kNoThrow,      \
                                 "Word32AtomicCompareExchange", 4, 1, 1, 1, 1, \
                                 0,                                            \
                                 AtomicOpParameters(MachineType::Type(),       \
                                                    MemoryAccessKind::k##Kind) \
          ) {}                                                                 \
  };                                                                           \
  Word32AtomicCompareExchange##Type##Kind##Operator                            \
      kWord32AtomicCompareExchange##Type##Kind;

Definition at line 1657 of file machine-operator.cc.

ATOMIC_COMPARE_EXCHANGE_WITH_KIND [2/2]

#define ATOMIC_COMPARE_EXCHANGE_WITH_KIND	(		Type,
			Kind )

Value:

  struct Word64AtomicCompareExchange##Type##Kind##Operator                     \
      : public Operator1<AtomicOpParameters> {                                 \
    Word64AtomicCompareExchange##Type##Kind##Operator()                        \
        : Operator1<AtomicOpParameters>(                                       \
                                 IrOpcode::kWord64AtomicCompareExchange,       \
                                 Operator::kNoDeopt | Operator::kNoThrow,      \
                                 "Word64AtomicCompareExchange", 4, 1, 1, 1, 1, \
                                 0,                                            \
                                 AtomicOpParameters(MachineType::Type(),       \
                                                    MemoryAccessKind::k##Kind) \
          ) {}                                                                 \
  };                                                                           \
  Word64AtomicCompareExchange##Type##Kind##Operator                            \
      kWord64AtomicCompareExchange##Type##Kind;

Definition at line 1657 of file machine-operator.cc.

ATOMIC_LOAD [1/2]

#define ATOMIC_LOAD

(

Type

)

Value:

  ATOMIC_LOAD_WITH_KIND(Type, Normal) \
  ATOMIC_LOAD_WITH_KIND(Type, ProtectedByTrapHandler)

Definition at line 1550 of file machine-operator.cc.

ATOMIC_LOAD [2/2]

#define ATOMIC_LOAD

(

Type

)

Value:

  ATOMIC_LOAD_WITH_KIND(Type, Normal) \
  ATOMIC_LOAD_WITH_KIND(Type, ProtectedByTrapHandler)

Definition at line 1550 of file machine-operator.cc.

ATOMIC_LOAD_WITH_KIND [1/2]

#define ATOMIC_LOAD_WITH_KIND	(		Type,
			Kind )

Value:

  struct Word32SeqCstLoad##Type##Kind##Operator                     \
      : public Operator1<AtomicLoadParameters> {                    \
    Word32SeqCstLoad##Type##Kind##Operator()                        \
        : Operator1<AtomicLoadParameters>(                          \
              IrOpcode::kWord32AtomicLoad, Operator::kNoProperties, \
              "Word32AtomicLoad", 2, 1, 1, 1, 1, 0,                 \
              AtomicLoadParameters(MachineType::Type(),             \
                                   AtomicMemoryOrder::kSeqCst,      \
                                   MemoryAccessKind::k##Kind)) {}   \
  };                                                                \
  Word32SeqCstLoad##Type##Kind##Operator kWord32SeqCstLoad##Type##Kind;

Definition at line 1538 of file machine-operator.cc.

ATOMIC_LOAD_WITH_KIND [2/2]

#define ATOMIC_LOAD_WITH_KIND	(		Type,
			Kind )

Value:

  struct Word64SeqCstLoad##Type##Kind##Operator                     \
      : public Operator1<AtomicLoadParameters> {                    \
    Word64SeqCstLoad##Type##Kind##Operator()                        \
        : Operator1<AtomicLoadParameters>(                          \
              IrOpcode::kWord64AtomicLoad, Operator::kNoProperties, \
              "Word64AtomicLoad", 2, 1, 1, 1, 1, 0,                 \
              AtomicLoadParameters(MachineType::Type(),             \
                                   AtomicMemoryOrder::kSeqCst,      \
                                   MemoryAccessKind::k##Kind)) {}   \
  };                                                                \
  Word64SeqCstLoad##Type##Kind##Operator kWord64SeqCstLoad##Type##Kind;

Definition at line 1538 of file machine-operator.cc.

ATOMIC_OP

#define ATOMIC_OP	(		op,
			type,
			kind )

Value:

  struct op##type##kind##Operator : public Operator1<AtomicOpParameters> {     \
    op##type##kind##Operator()                                                 \
        : Operator1<AtomicOpParameters>(IrOpcode::k##op,                       \
                                 Operator::kNoDeopt | Operator::kNoThrow, #op, \
                                 3, 1, 1, 1, 1, 0,                             \
                                 AtomicOpParameters(MachineType::type(),       \
                                                    MemoryAccessKind::k##kind) \
                                 ){}                                           \
  };                                                                           \
  op##type##kind##Operator k##op##type##kind;

Definition at line 1618 of file machine-operator.cc.

ATOMIC_OP_LIST

#define ATOMIC_OP_LIST

(

type

)

Value:

  ATOMIC_OP_LIST_WITH_KIND(type, Normal) \
  ATOMIC_OP_LIST_WITH_KIND(type, ProtectedByTrapHandler)

Definition at line 1636 of file machine-operator.cc.

ATOMIC_OP_LIST_WITH_KIND

#define ATOMIC_OP_LIST_WITH_KIND	(		type,
			kind )

Value:

  ATOMIC_OP(Word32AtomicAdd, type, kind)     \
  ATOMIC_OP(Word32AtomicSub, type, kind)     \
  ATOMIC_OP(Word32AtomicAnd, type, kind)     \
  ATOMIC_OP(Word32AtomicOr, type, kind)      \
  ATOMIC_OP(Word32AtomicXor, type, kind)     \
  ATOMIC_OP(Word32AtomicExchange, type, kind)

Definition at line 1629 of file machine-operator.cc.

ATOMIC_PAIR_BINOP_LIST

#define ATOMIC_PAIR_BINOP_LIST

(

V

)

Value:

  V(Add)                          \
  V(Sub)                          \
  V(And)                          \
  V(Or)                           \
  V(Xor)                          \
  V(Exchange)

Definition at line 1128 of file machine-operator.cc.

ATOMIC_PAIR_OP

#define ATOMIC_PAIR_OP

(

op

)

Value:

  struct Word32AtomicPair##op##Operator : public Operator {     \
    Word32AtomicPair##op##Operator()                            \
        : Operator(IrOpcode::kWord32AtomicPair##op,             \
                   Operator::kNoDeopt | Operator::kNoThrow,     \
                   "Word32AtomicPair" #op, 4, 1, 1, 2, 1, 0) {} \
  };                                                            \
  Word32AtomicPair##op##Operator kWord32AtomicPair##op;

Definition at line 1719 of file machine-operator.cc.

ATOMIC_REPRESENTATION_LIST

#define ATOMIC_REPRESENTATION_LIST

(

V

)

Value:

  V(kWord8)                           \
  V(kWord16)                          \
  V(kWord32)

Definition at line 1119 of file machine-operator.cc.

ATOMIC_STORE [1/2]

#define ATOMIC_STORE

(

Type

)

Value:

  ATOMIC_STORE_WITH_KIND(Type, Normal) \
  ATOMIC_STORE_WITH_KIND(Type, ProtectedByTrapHandler)

Definition at line 1590 of file machine-operator.cc.

ATOMIC_STORE [2/2]

#define ATOMIC_STORE

(

Type

)

Value:

  ATOMIC_STORE_WITH_KIND(Type, Normal) \
  ATOMIC_STORE_WITH_KIND(Type, ProtectedByTrapHandler)

Definition at line 1590 of file machine-operator.cc.

ATOMIC_STORE_WITH_KIND [1/2]

#define ATOMIC_STORE_WITH_KIND	(		Type,
			Kind )

Value:

  struct Word32SeqCstStore##Type##Kind##Operator                           \
      : public Operator1<AtomicStoreParameters> {                          \
    Word32SeqCstStore##Type##Kind##Operator()                              \
        : Operator1<AtomicStoreParameters>(                                \
              IrOpcode::kWord32AtomicStore,                                \
              Operator::kNoDeopt | Operator::kNoRead | Operator::kNoThrow, \
              "Word32AtomicStore", 3, 1, 1, 0, 1, 0,                       \
              AtomicStoreParameters(MachineRepresentation::Type,           \
                                    kNoWriteBarrier,                       \
                                    AtomicMemoryOrder::kSeqCst,            \
                                    MemoryAccessKind::k##Kind)) {}         \
  };                                                                       \
  Word32SeqCstStore##Type##Kind##Operator kWord32SeqCstStore##Type##Kind;

Definition at line 1576 of file machine-operator.cc.

ATOMIC_STORE_WITH_KIND [2/2]

#define ATOMIC_STORE_WITH_KIND	(		Type,
			Kind )

Value:

  struct Word64SeqCstStore##Type##Kind##Operator                           \
      : public Operator1<AtomicStoreParameters> {                          \
    Word64SeqCstStore##Type##Kind##Operator()                              \
        : Operator1<AtomicStoreParameters>(                                \
              IrOpcode::kWord64AtomicStore,                                \
              Operator::kNoDeopt | Operator::kNoRead | Operator::kNoThrow, \
              "Word64AtomicStore", 3, 1, 1, 0, 1, 0,                       \
              AtomicStoreParameters(MachineRepresentation::Type,           \
                                    kNoWriteBarrier,                       \
                                    AtomicMemoryOrder::kSeqCst,            \
                                    MemoryAccessKind::k##Kind)) {}         \
  };                                                                       \
  Word64SeqCstStore##Type##Kind##Operator kWord64SeqCstStore##Type##Kind;

Definition at line 1576 of file machine-operator.cc.

ATOMIC_TAGGED_REPRESENTATION_LIST

#define ATOMIC_TAGGED_REPRESENTATION_LIST

(

V

)

Value:

  V(kTaggedSigned)                           \
  V(kTaggedPointer)                          \
  V(kTagged)                                 \
  V(kCompressedPointer)                      \
  V(kCompressed)

Definition at line 1108 of file machine-operator.cc.

ATOMIC_TAGGED_TYPE_LIST

#define ATOMIC_TAGGED_TYPE_LIST

(

V

)

Value:

  V(TaggedSigned)                  \
  V(TaggedPointer)                 \
  V(AnyTagged)                     \
  V(CompressedPointer)             \
  V(AnyCompressed)

Definition at line 1071 of file machine-operator.cc.

ATOMIC_TYPE_LIST

#define ATOMIC_TYPE_LIST

(

V

)

Value:

  ATOMIC_U32_TYPE_LIST(V)   \
  V(Int8)                   \
  V(Int16)                  \
  V(Int32)

Definition at line 1087 of file machine-operator.cc.

ATOMIC_U32_TYPE_LIST

#define ATOMIC_U32_TYPE_LIST

(

V

)

Value:

  V(Uint8)                      \
  V(Uint16)                     \
  V(Uint32)

Definition at line 1082 of file machine-operator.cc.

ATOMIC_U64_TYPE_LIST

#define ATOMIC_U64_TYPE_LIST

(

V

)

Value:

  ATOMIC_U32_TYPE_LIST(V)       \
  V(Uint64)

Definition at line 1093 of file machine-operator.cc.

CACHED_LOAD [1/2]

#define CACHED_LOAD

(

Type

)

Value:

  CACHED_LOAD_WITH_KIND(Type, Normal) \
  CACHED_LOAD_WITH_KIND(Type, ProtectedByTrapHandler)

CACHED_LOAD [2/2]

#define CACHED_LOAD

(

Type

)

Value:

  CACHED_LOAD_WITH_KIND(Type, Normal) \
  CACHED_LOAD_WITH_KIND(Type, ProtectedByTrapHandler)

CACHED_LOAD_WITH_KIND [1/2]

#define CACHED_LOAD_WITH_KIND	(		Type,
			Kind )

Value:

  if (params.representation() == MachineType::Type() && \
      params.order() == AtomicMemoryOrder::kSeqCst &&   \
      params.kind() == MemoryAccessKind::k##Kind) {     \
    return &cache_.kWord32SeqCstLoad##Type##Kind;       \
  }

CACHED_LOAD_WITH_KIND [2/2]

#define CACHED_LOAD_WITH_KIND	(		Type,
			Kind )

Value:

  if (params.representation() == MachineType::Type() && \
      params.order() == AtomicMemoryOrder::kSeqCst &&   \
      params.kind() == MemoryAccessKind::k##Kind) {     \
    return &cache_.kWord64SeqCstLoad##Type##Kind;       \
  }

CACHED_STORE [1/2]

#define CACHED_STORE

(

kRep

)

Value:

  CACHED_STORE_WITH_KIND(kRep, Normal) \
  CACHED_STORE_WITH_KIND(kRep, ProtectedByTrapHandler)

CACHED_STORE [2/2]

#define CACHED_STORE

(

kRep

)

Value:

  CACHED_STORE_WITH_KIND(kRep, Normal) \
  CACHED_STORE_WITH_KIND(kRep, ProtectedByTrapHandler)

CACHED_STORE_WITH_KIND [1/2]

#define CACHED_STORE_WITH_KIND	(		kRep,
			Kind )

Value:

  if (params.representation() == MachineRepresentation::kRep && \
      params.order() == AtomicMemoryOrder::kSeqCst &&           \
      params.kind() == MemoryAccessKind::k##Kind) {             \
    return &cache_.kWord32SeqCstStore##kRep##Kind;              \
  }

CACHED_STORE_WITH_KIND [2/2]

#define CACHED_STORE_WITH_KIND	(		kRep,
			Kind )

Value:

  if (params.representation() == MachineRepresentation::kRep && \
      params.order() == AtomicMemoryOrder::kSeqCst &&           \
      params.kind() == MemoryAccessKind::k##Kind) {             \
    return &cache_.kWord64SeqCstStore##kRep##Kind;              \
  }

CASE_CACHED_SIZE

#define CASE_CACHED_SIZE	(		Size,
			Alignment,
			IsTagged )

Value:

  if (size == Size && alignment == Alignment && is_tagged == IsTagged) {     \
    return &cache_.kStackSlotOfSize##Size##OfAlignment##Alignment##IsTagged; \
  }

COMPARE_EXCHANGE

#define COMPARE_EXCHANGE

(

kType

)

Value:

  COMPARE_EXCHANGE_WITH_KIND(kType, Normal) \
  COMPARE_EXCHANGE_WITH_KIND(kType, ProtectedByTrapHandler)

COMPARE_EXCHANGE_WITH_KIND

#define COMPARE_EXCHANGE_WITH_KIND	(		kType,
			Kind )

Value:

  if (params.type() == MachineType::kType()                   \
      && params.kind() == MemoryAccessKind::k##Kind) {        \
    return &cache_.kWord32AtomicCompareExchange##kType##Kind; \
  }

EXCHANGE

#define EXCHANGE

(

kType

)

Value:

  EXCHANGE_WITH_KIND(kType, Normal) \
  EXCHANGE_WITH_KIND(kType, ProtectedByTrapHandler)

EXCHANGE_WITH_KIND

#define EXCHANGE_WITH_KIND	(		kType,
			Kind )

Value:

  if (params.type() == MachineType::kType()            \
      && params.kind() == MemoryAccessKind::k##Kind) { \
    return &cache_.kWord32AtomicExchange##kType##Kind; \
  }

LOAD [1/8]

#define LOAD

(

Type

)

Definition at line 1295 of file machine-operator.cc.

LOAD [2/8]

#define LOAD

(

Type

)

Value:

  if (rep == MachineType::Type()) {      \
    return &cache_.kUnalignedLoad##Type; \
  }

Definition at line 1295 of file machine-operator.cc.

LOAD [3/8]

#define LOAD

(

Type

)

Value:

  if (rep == MachineType::Type()) { \
    return &cache_.kLoad##Type;     \
  }

Definition at line 1295 of file machine-operator.cc.

LOAD [4/8]

#define LOAD

(

Type

)

Value:

  if (rep == MachineType::Type()) {      \
    return &cache_.kLoadImmutable##Type; \
  }

Definition at line 1295 of file machine-operator.cc.

LOAD [5/8]

#define LOAD

(

Type

)

Value:

  if (rep == MachineType::Type()) {      \
    return &cache_.kProtectedLoad##Type; \
  }

Definition at line 1295 of file machine-operator.cc.

LOAD [6/8]

#define LOAD

(

Type

)

Value:

  if (rep == MachineType::Type()) {       \
    return &cache_.kLoadTrapOnNull##Type; \
  }

Definition at line 1295 of file machine-operator.cc.

LOAD [7/8]

#define LOAD

(

Type

)

Value:

  if (params.representation() == MachineType::Type()) {       \
    return zone_->New<Operator1<AtomicLoadParameters>>(       \
        IrOpcode::kWord32AtomicLoad, Operator::kNoProperties, \
        "Word32AtomicLoad", 2, 1, 1, 1, 1, 0, params);        \
  }

Definition at line 1295 of file machine-operator.cc.

LOAD [8/8]

#define LOAD

(

Type

)

Value:

  if (params.representation() == MachineType::Type()) {       \
    return zone_->New<Operator1<AtomicLoadParameters>>(       \
        IrOpcode::kWord64AtomicLoad, Operator::kNoProperties, \
        "Word64AtomicLoad", 2, 1, 1, 1, 1, 0, params);        \
  }

Definition at line 1295 of file machine-operator.cc.

LOAD_TRANSFORM_LIST

#define LOAD_TRANSFORM_LIST

(

V

)

Value:

  V(S128Load8Splat)            \
  V(S128Load16Splat)           \
  V(S128Load32Splat)           \
  V(S128Load64Splat)           \
  V(S128Load8x8S)              \
  V(S128Load8x8U)              \
  V(S128Load16x4S)             \
  V(S128Load16x4U)             \
  V(S128Load32x2S)             \
  V(S128Load32x2U)             \
  V(S128Load32Zero)            \
  V(S128Load64Zero)            \
  V(S256Load8Splat)            \
  V(S256Load16Splat)           \
  V(S256Load32Splat)           \
  V(S256Load64Splat)           \
  V(S256Load8x16S)             \
  V(S256Load8x16U)             \
  V(S256Load16x8S)             \
  V(S256Load16x8U)             \
  V(S256Load32x4S)             \
  V(S256Load32x4U)

Definition at line 1034 of file machine-operator.cc.

MACHINE_PURE_OP_LIST

#define MACHINE_PURE_OP_LIST

(

V

)

Definition at line 770 of file machine-operator.cc.

MACHINE_REPRESENTATION_LIST

#define MACHINE_REPRESENTATION_LIST

(

V

)

Value:

  V(kFloat16)                          \
  V(kFloat32)                          \
  V(kFloat64)                          \
  V(kSimd128)                          \
  V(kWord8)                            \
  V(kWord16)                           \
  V(kWord32)                           \
  V(kWord64)                           \
  V(kMapWord)                          \
  V(kTaggedSigned)                     \
  V(kTaggedPointer)                    \
  V(kTagged)                           \
  V(kCompressedPointer)                \
  V(kSandboxedPointer)                 \
  V(kCompressed)                       \
  V(kSimd256)

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

MACHINE_TYPE_LIST

#define MACHINE_TYPE_LIST

(

V

)

Value:

  V(Float16)                 \
  V(Float32)                 \
  V(Float64)                 \
  V(Simd128)                 \
  V(Int8)                    \
  V(Uint8)                   \
  V(Int16)                   \
  V(Uint16)                  \
  V(Int32)                   \
  V(Uint32)                  \
  V(Int64)                   \
  V(Uint64)                  \
  V(Pointer)                 \
  V(TaggedSigned)            \
  V(TaggedPointer)           \
  V(MapInHeader)             \
  V(AnyTagged)               \
  V(CompressedPointer)       \
  V(ProtectedPointer)        \
  V(SandboxedPointer)        \
  V(AnyCompressed)           \
  V(Simd256)

Definition at line 920 of file machine-operator.cc.

OP [1/12]

#define OP

(

kType

)

Value:

  OP_WITH_KIND(kType, Normal) \
  OP_WITH_KIND(kType, ProtectedByTrapHandler)

OP [2/12]

#define OP

(

kType

)

Value:

  OP_WITH_KIND(kType, Normal) \
  OP_WITH_KIND(kType, ProtectedByTrapHandler)

OP [3/12]

#define OP

(

kType

)

Value:

  OP_WITH_KIND(kType, Normal) \
  OP_WITH_KIND(kType, ProtectedByTrapHandler)

OP [4/12]

#define OP

(

kType

)

Value:

  OP_WITH_KIND(kType, Normal) \
  OP_WITH_KIND(kType, ProtectedByTrapHandler)

OP [5/12]

#define OP

(

kType

)

Value:

  OP_WITH_KIND(kType, Normal) \
  OP_WITH_KIND(kType, ProtectedByTrapHandler)

OP [6/12]

#define OP

(

kType

)

Value:

  OP_WITH_KIND(kType, Normal) \
  OP_WITH_KIND(kType, ProtectedByTrapHandler)

OP [7/12]

#define OP

(

kType

)

Value:

  OP_WITH_KIND(kType, Normal) \
  OP_WITH_KIND(kType, ProtectedByTrapHandler)

OP [8/12]

#define OP

(

kType

)

Value:

  OP_WITH_KIND(kType, Normal) \
  OP_WITH_KIND(kType, ProtectedByTrapHandler)

OP [9/12]

#define OP

(

kType

)

Value:

  OP_WITH_KIND(kType, Normal) \
  OP_WITH_KIND(kType, ProtectedByTrapHandler)

OP [10/12]

#define OP

(

kType

)

Value:

  OP_WITH_KIND(kType, Normal) \
  OP_WITH_KIND(kType, ProtectedByTrapHandler)

OP [11/12]

#define OP

(

kType

)

Value:

  OP_WITH_KIND(kType, Normal) \
  OP_WITH_KIND(kType, ProtectedByTrapHandler)

OP [12/12]

#define OP

(

kType

)

Value:

  OP_WITH_KIND(kType, Normal) \
  OP_WITH_KIND(kType, ProtectedByTrapHandler)

OP_WITH_KIND [1/12]

#define OP_WITH_KIND	(		kType,
			Kind )

Value:

  if (params.type() == MachineType::kType()            \
      && params.kind() == MemoryAccessKind::k##Kind) { \
    return &cache_.kWord32AtomicAdd##kType##Kind;      \
  }

OP_WITH_KIND [2/12]

#define OP_WITH_KIND	(		kType,
			Kind )

Value:

  if (params.type() == MachineType::kType()            \
      && params.kind() == MemoryAccessKind::k##Kind) { \
    return &cache_.kWord32AtomicSub##kType##Kind;      \
  }

OP_WITH_KIND [3/12]

#define OP_WITH_KIND	(		kType,
			Kind )

Value:

  if (params.type() == MachineType::kType()            \
      && params.kind() == MemoryAccessKind::k##Kind) { \
    return &cache_.kWord32AtomicAnd##kType##Kind;      \
  }

OP_WITH_KIND [4/12]

#define OP_WITH_KIND	(		kType,
			Kind )

Value:

  if (params.type() == MachineType::kType()            \
      && params.kind() == MemoryAccessKind::k##Kind) { \
    return &cache_.kWord32AtomicOr##kType##Kind;       \
  }

OP_WITH_KIND [5/12]

#define OP_WITH_KIND	(		kType,
			Kind )

Value:

  if (params.type() == MachineType::kType()            \
      && params.kind() == MemoryAccessKind::k##Kind) { \
    return &cache_.kWord32AtomicXor##kType##Kind;      \
  }

OP_WITH_KIND [6/12]

#define OP_WITH_KIND	(		kType,
			Kind )

Value:

  if (params.type() == MachineType::kType()            \
      && params.kind() == MemoryAccessKind::k##Kind) { \
    return &cache_.kWord64AtomicAdd##kType##Kind;      \
  }

OP_WITH_KIND [7/12]

#define OP_WITH_KIND	(		kType,
			Kind )

Value:

  if (params.type() == MachineType::kType()            \
      && params.kind() == MemoryAccessKind::k##Kind) { \
    return &cache_.kWord64AtomicSub##kType##Kind;      \
  }

OP_WITH_KIND [8/12]

#define OP_WITH_KIND	(		kType,
			Kind )

Value:

  if (params.type() == MachineType::kType()            \
      && params.kind() == MemoryAccessKind::k##Kind) { \
    return &cache_.kWord64AtomicAnd##kType##Kind;      \
  }

OP_WITH_KIND [9/12]

#define OP_WITH_KIND	(		kType,
			Kind )

Value:

  if (params.type() == MachineType::kType()            \
      && params.kind() == MemoryAccessKind::k##Kind) { \
    return &cache_.kWord64AtomicOr##kType##Kind;      \
  }

OP_WITH_KIND [10/12]

#define OP_WITH_KIND	(		kType,
			Kind )

Value:

  if (params.type() == MachineType::kType()            \
      && params.kind() == MemoryAccessKind::k##Kind) { \
    return &cache_.kWord64AtomicXor##kType##Kind;      \
  }

OP_WITH_KIND [11/12]

#define OP_WITH_KIND	(		kType,
			Kind )

Value:

  if (params.type() == MachineType::kType()                 \
      && params.kind() == MemoryAccessKind::k##Kind) {      \
    return &cache_.kWord64AtomicExchange##kType##Kind;      \
  }

OP_WITH_KIND [12/12]

#define OP_WITH_KIND	(		kType,
			Kind )

Value:

  if (params.type() == MachineType::kType()                   \
      && params.kind() == MemoryAccessKind::k##Kind) {        \
    return &cache_.kWord64AtomicCompareExchange##kType##Kind; \
  }

OVERFLOW_OP [1/2]

#define OVERFLOW_OP	(		Name,
			properties )

Value:

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

Definition at line 1282 of file machine-operator.cc.

OVERFLOW_OP [2/2]

#define OVERFLOW_OP	(		Name,
			properties )

Value:

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

Definition at line 1282 of file machine-operator.cc.

OVERFLOW_OP_LIST

#define OVERFLOW_OP_LIST

(

V

)

Value:

  V(Int32AddWithOverflow, Operator::kAssociative | Operator::kCommutative) \
  V(Int32SubWithOverflow, Operator::kNoProperties)                         \
  V(Int32MulWithOverflow, Operator::kAssociative | Operator::kCommutative) \
  V(Int64AddWithOverflow, Operator::kAssociative | Operator::kCommutative) \
  V(Int64SubWithOverflow, Operator::kNoProperties)                         \
  V(Int64MulWithOverflow, Operator::kAssociative | Operator::kCommutative)

Definition at line 912 of file machine-operator.cc.

PURE [1/3]

#define PURE	(		Name,
			properties,
			value_input_count,
			control_input_count,
			output_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, output_count, 0, \
                   0) {}                                                       \
  };                                                                           \
  Name##Operator k##Name;

Definition at line 1167 of file machine-operator.cc.

PURE [2/3]

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

Value:

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

Definition at line 1167 of file machine-operator.cc.

PURE [3/3]

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

Value:

  const OptionalOperator MachineOperatorBuilder::Name() {              \
    return OptionalOperator(flags_ & k##Name, &cache_.k##Name);        \
  }

Definition at line 1167 of file machine-operator.cc.

PURE_BINARY_OP_LIST_32

#define PURE_BINARY_OP_LIST_32

(

V

)

Value:

  V(Word32And, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)    \
  V(Word32Or, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)     \
  V(Word32Xor, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)    \
  V(Word32Shl, Operator::kNoProperties, 2, 0, 1)                            \
  V(Word32Shr, Operator::kNoProperties, 2, 0, 1)                            \
  V(Word32Ror, Operator::kNoProperties, 2, 0, 1)                            \
  V(Word32Equal, Operator::kCommutative, 2, 0, 1)                           \
  V(Int32Add, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)     \
  V(Int32Sub, Operator::kNoProperties, 2, 0, 1)                             \
  V(Int32Mul, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)     \
  V(Int32MulHigh, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
  V(Int32Div, Operator::kNoProperties, 2, 1, 1)                             \
  V(Int32Mod, Operator::kNoProperties, 2, 1, 1)                             \
  V(Int32LessThan, Operator::kNoProperties, 2, 0, 1)                        \
  V(Int32LessThanOrEqual, Operator::kNoProperties, 2, 0, 1)                 \
  V(Uint32Div, Operator::kNoProperties, 2, 1, 1)                            \
  V(Uint32LessThan, Operator::kNoProperties, 2, 0, 1)                       \
  V(Uint32LessThanOrEqual, Operator::kNoProperties, 2, 0, 1)                \
  V(Uint32Mod, Operator::kNoProperties, 2, 1, 1)                            \
  V(Uint32MulHigh, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)

Definition at line 319 of file machine-operator.cc.

PURE_BINARY_OP_LIST_64

#define PURE_BINARY_OP_LIST_64

(

V

)

Value:

  V(Word64And, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)     \
  V(Word64Or, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)      \
  V(Word64Xor, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)     \
  V(Word64Shl, Operator::kNoProperties, 2, 0, 1)                             \
  V(Word64Shr, Operator::kNoProperties, 2, 0, 1)                             \
  V(Word64Ror, Operator::kNoProperties, 2, 0, 1)                             \
  V(Word64RorLowerable, Operator::kNoProperties, 2, 1, 1)                    \
  V(Word64Equal, Operator::kCommutative, 2, 0, 1)                            \
  V(Int64Add, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)      \
  V(Int64Sub, Operator::kNoProperties, 2, 0, 1)                              \
  V(Int64Mul, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)      \
  V(Int64MulHigh, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)  \
  V(Int64Div, Operator::kNoProperties, 2, 1, 1)                              \
  V(Int64Mod, Operator::kNoProperties, 2, 1, 1)                              \
  V(Int64LessThan, Operator::kNoProperties, 2, 0, 1)                         \
  V(Int64LessThanOrEqual, Operator::kNoProperties, 2, 0, 1)                  \
  V(Uint64MulHigh, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
  V(Uint64Div, Operator::kNoProperties, 2, 1, 1)                             \
  V(Uint64Mod, Operator::kNoProperties, 2, 1, 1)                             \
  V(Uint64LessThan, Operator::kNoProperties, 2, 0, 1)                        \
  V(Uint64LessThanOrEqual, Operator::kNoProperties, 2, 0, 1)

Definition at line 343 of file machine-operator.cc.

PURE_OPTIONAL_OP_LIST

#define PURE_OPTIONAL_OP_LIST

(

V

)

Value:

  V(Word32Ctz, Operator::kNoProperties, 1, 0, 1)            \
  V(Word64Ctz, Operator::kNoProperties, 1, 0, 1)            \
  V(Word64CtzLowerable, Operator::kNoProperties, 1, 1, 1)   \
  V(Word32Rol, Operator::kNoProperties, 2, 0, 1)            \
  V(Word64Rol, Operator::kNoProperties, 2, 0, 1)            \
  V(Word64RolLowerable, Operator::kNoProperties, 2, 1, 1)   \
  V(Word32ReverseBits, Operator::kNoProperties, 1, 0, 1)    \
  V(Word64ReverseBits, Operator::kNoProperties, 1, 0, 1)    \
  V(Int32AbsWithOverflow, Operator::kNoProperties, 1, 0, 2) \
  V(Int64AbsWithOverflow, Operator::kNoProperties, 1, 0, 2) \
  V(Word32Popcnt, Operator::kNoProperties, 1, 0, 1)         \
  V(Word64Popcnt, Operator::kNoProperties, 1, 0, 1)         \
  V(Float32RoundDown, Operator::kNoProperties, 1, 0, 1)     \
  V(Float64RoundDown, Operator::kNoProperties, 1, 0, 1)     \
  V(Float32RoundUp, Operator::kNoProperties, 1, 0, 1)       \
  V(Float64RoundUp, Operator::kNoProperties, 1, 0, 1)       \
  V(Float32RoundTruncate, Operator::kNoProperties, 1, 0, 1) \
  V(Float64RoundTruncate, Operator::kNoProperties, 1, 0, 1) \
  V(Float64RoundTiesAway, Operator::kNoProperties, 1, 0, 1) \
  V(Float32RoundTiesEven, Operator::kNoProperties, 1, 0, 1) \
  V(Float64RoundTiesEven, Operator::kNoProperties, 1, 0, 1) \
  V(Word32Select, Operator::kNoProperties, 3, 0, 1)         \
  V(Word64Select, Operator::kNoProperties, 3, 0, 1)         \
  V(Float32Select, Operator::kNoProperties, 3, 0, 1)        \
  V(Float64Select, Operator::kNoProperties, 3, 0, 1)

Definition at line 883 of file machine-operator.cc.

PURE_SIMD_OP_LIST

#define PURE_SIMD_OP_LIST

(

V

)

Definition at line 368 of file machine-operator.cc.

SIMD_I16x8_LANES

#define SIMD_I16x8_LANES

(

V

)

Value:

SIMD_I32x4_LANES(V) V(4) V(5) V(6) V(7)

Definition at line 1149 of file machine-operator.cc.

SIMD_I32x4_LANES

#define SIMD_I32x4_LANES

(

V

)

Value:

SIMD_I64x2_LANES(V) V(2) V(3)

Definition at line 1147 of file machine-operator.cc.

SIMD_I64x2_LANES

#define SIMD_I64x2_LANES

(

V

)

Value:

V(0) V(1)

Definition at line 1145 of file machine-operator.cc.

SIMD_I8x16_LANES

#define SIMD_I8x16_LANES

(

V

)

Value:

  SIMD_I16x8_LANES(V) V(8) V(9) V(10) V(11) V(12) V(13) V(14) V(15)

Definition at line 1151 of file machine-operator.cc.

SIMD_LANE_OP_LIST

#define SIMD_LANE_OP_LIST

(

V

)

Value:

  V(F64x2, 2)                \
  V(F32x4, 4)                \
  V(I64x2, 2)                \
  V(I32x4, 4)                \
  V(F16x8, 8)                \
  V(I16x8, 8)                \
  V(I8x16, 16)

Definition at line 1136 of file machine-operator.cc.

STACK_POINTER_GREATER_THAN

#define STACK_POINTER_GREATER_THAN

(

Kind

)

Value:

  struct StackPointerGreaterThan##Kind##Operator final                \
      : public StackPointerGreaterThanOperator {                      \
    StackPointerGreaterThan##Kind##Operator()                         \
        : StackPointerGreaterThanOperator(StackCheckKind::k##Kind) {} \
  };                                                                  \
  StackPointerGreaterThan##Kind##Operator kStackPointerGreaterThan##Kind;

Definition at line 1798 of file machine-operator.cc.

STACK_SLOT_CACHED_SIZES_ALIGNMENTS_LIST

#define STACK_SLOT_CACHED_SIZES_ALIGNMENTS_LIST

(

V

)

Value:

  V(4, 0, false)                                   \
  V(8, 0, false) V(16, 0, false) V(4, 4, false) V(8, 8, false) V(16, 16, false)

Definition at line 1154 of file machine-operator.cc.

STACKSLOT

#define STACKSLOT	(		Size,
			Alignment,
			IsTagged )

Value:

  struct StackSlotOfSize##Size##OfAlignment##Alignment##IsTagged##Operator \
      final : public StackSlotOperator {                                   \
    StackSlotOfSize##Size##OfAlignment##Alignment##IsTagged##Operator()    \
        : StackSlotOperator(Size, Alignment, IsTagged) {}                  \
  };                                                                       \
  StackSlotOfSize##Size##OfAlignment##Alignment##IsTagged##Operator        \
      kStackSlotOfSize##Size##OfAlignment##Alignment##IsTagged;

Definition at line 1367 of file machine-operator.cc.

STORE [1/8]

#define STORE

(

kRep

)

Value:

  case MachineRepresentation::kRep: \
    return &cache_.kUnalignedStore##kRep;

Definition at line 1378 of file machine-operator.cc.

STORE [2/8]

#define STORE

(

kRep

)

Value:

  case MachineRepresentation::kRep:                              \
    switch (store_rep.write_barrier_kind()) {                    \
      case kNoWriteBarrier:                                      \
        return &cache_.k##Store##kRep##NoWriteBarrier;           \
      case kAssertNoWriteBarrier:                                \
        return &cache_.k##Store##kRep##AssertNoWriteBarrier;     \
      case kMapWriteBarrier:                                     \
        return &cache_.k##Store##kRep##MapWriteBarrier;          \
      case kPointerWriteBarrier:                                 \
        return &cache_.k##Store##kRep##PointerWriteBarrier;      \
      case kIndirectPointerWriteBarrier:                         \
        UNREACHABLE();                                           \
      case kEphemeronKeyWriteBarrier:                            \
        return &cache_.k##Store##kRep##EphemeronKeyWriteBarrier; \
      case kFullWriteBarrier:                                    \
        return &cache_.k##Store##kRep##FullWriteBarrier;         \
    }                                                            \
    break;

Definition at line 1378 of file machine-operator.cc.

STORE [3/8]

#define STORE

(

kRep

)

Value:

  case MachineRepresentation::kRep: \
    return &cache_.kProtectedStore##kRep;

Definition at line 1378 of file machine-operator.cc.

STORE [4/8]

#define STORE

(

kRep

)

Value:

  case MachineRepresentation::kRep:                          \
    if (rep.write_barrier_kind() == kNoWriteBarrier) {       \
      return &cache_.kStoreTrapOnNull##kRep##NoWriteBarrier; \
    }                                                        \
    DCHECK_EQ(kFullWriteBarrier, rep.write_barrier_kind());  \
    return &cache_.kStoreTrapOnNull##kRep##FullWriteBarrier;

Definition at line 1378 of file machine-operator.cc.

STORE [5/8]

#define STORE

(

kRep

)

Value:

  if (params.representation() == MachineRepresentation::kRep) {      \
    return zone_->New<Operator1<AtomicStoreParameters>>(             \
        IrOpcode::kWord32AtomicStore,                                \
        Operator::kNoDeopt | Operator::kNoRead | Operator::kNoThrow, \
        "Word32AtomicStore", 3, 1, 1, 0, 1, 0, params);              \
  }

Definition at line 1378 of file machine-operator.cc.

STORE [6/8]

#define STORE

(

kRep

)

Value:

  if (params.representation() == MachineRepresentation::kRep) {      \
    return zone_->New<Operator1<AtomicStoreParameters>>(             \
        IrOpcode::kWord64AtomicStore,                                \
        Operator::kNoDeopt | Operator::kNoRead | Operator::kNoThrow, \
        "Word64AtomicStore", 3, 1, 1, 0, 1, 0, params);              \
  }

Definition at line 1378 of file machine-operator.cc.

STORE [7/8]

#define STORE	(		kRep1,
			kRep2 )

Value:

  static_assert(ElementSizeLog2Of(MachineRepresentation::kRep1) ==   \
                ElementSizeLog2Of(MachineRepresentation::kRep2));    \
  if (MachineRepresentation::kRep1 == store_rep1.representation() && \
      MachineRepresentation::kRep2 == store_rep2.representation()) { \
    if (store_rep1.write_barrier_kind() != kNoWriteBarrier ||        \
        store_rep2.write_barrier_kind() != kNoWriteBarrier) {        \
      return {};                                                     \
    }                                                                \
    return &cache_.k##StorePair##kRep1##kRep2##NoWriteBarrier;       \
  }

Definition at line 1378 of file machine-operator.cc.

STORE [8/8]

#define STORE

(

Type

)

Definition at line 1378 of file machine-operator.cc.

STORE_PAIR

#define STORE_PAIR	(		Type1,
			Type2 )

Value:

  struct StorePair##Type1##Type2##Operator                                 \
      : public Operator1<StorePairRepresentation> {                        \
    explicit StorePair##Type1##Type2##Operator(                            \
        WriteBarrierKind write_barrier_kind1,                              \
        WriteBarrierKind write_barrier_kind2)                              \
        : Operator1<StorePairRepresentation>(                              \
              IrOpcode::kStorePair,                                        \
              Operator::kNoDeopt | Operator::kNoRead | Operator::kNoThrow, \
              "StorePair", 4, 1, 1, 0, 1, 0,                               \
              {                                                            \
                  StoreRepresentation(MachineRepresentation::Type1,        \
                                      write_barrier_kind1),                \
                  StoreRepresentation(MachineRepresentation::Type2,        \
                                      write_barrier_kind2),                \
              }) {}                                                        \
  };                                                                       \
  struct StorePair##Type1##Type2##NoWriteBarrier##Operator final           \
      : public StorePair##Type1##Type2##Operator {                         \
    StorePair##Type1##Type2##NoWriteBarrier##Operator()                    \
        : StorePair##Type1##Type2                                          \
          ##Operator(kNoWriteBarrier, kNoWriteBarrier) {}                  \
  };                                                                       \
  StorePair##Type1##Type2##NoWriteBarrier##Operator                        \
      kStorePair##Type1##Type2##NoWriteBarrier;

Definition at line 1481 of file machine-operator.cc.

STORE_PAIR_MACHINE_REPRESENTATION_LIST

#define STORE_PAIR_MACHINE_REPRESENTATION_LIST

(

V

)

Definition at line 1030 of file machine-operator.cc.