src/compiler/representation-change.h - v8/v8 - Git at Google

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #ifndef V8_COMPILER_REPRESENTATION_CHANGE_H_
 #define V8_COMPILER_REPRESENTATION_CHANGE_H_

 #include "src/compiler/js-graph.h"
 #include "src/compiler/simplified-operator.h"

 namespace v8 {
 namespace internal {
 namespace compiler {

 enum IdentifyZeros { kIdentifyZeros, kDistinguishZeros };

 class Truncation final {
  public:
   // Constructors.
   static Truncation None() {
     return Truncation(TruncationKind::kNone, kIdentifyZeros);
   }
   static Truncation Bool() {
     return Truncation(TruncationKind::kBool, kIdentifyZeros);
   }
   static Truncation Word32() {
     return Truncation(TruncationKind::kWord32, kIdentifyZeros);
   }
   static Truncation Word64() {
     return Truncation(TruncationKind::kWord64, kIdentifyZeros);
   }
   static Truncation Float64(IdentifyZeros identify_zeros = kDistinguishZeros) {
     return Truncation(TruncationKind::kFloat64, identify_zeros);
   }
   static Truncation Any(IdentifyZeros identify_zeros = kDistinguishZeros) {
     return Truncation(TruncationKind::kAny, identify_zeros);
   }

   static Truncation Generalize(Truncation t1, Truncation t2) {
     return Truncation(
         Generalize(t1.kind(), t2.kind()),
         GeneralizeIdentifyZeros(t1.identify_zeros(), t2.identify_zeros()));
   }

   // Queries.
   bool IsUnused() const { return kind_ == TruncationKind::kNone; }
   bool IsUsedAsBool() const {
     return LessGeneral(kind_, TruncationKind::kBool);
   }
   bool IsUsedAsWord32() const {
     return LessGeneral(kind_, TruncationKind::kWord32);
   }
   bool IsUsedAsFloat64() const {
     return LessGeneral(kind_, TruncationKind::kFloat64);
   }
   bool IdentifiesUndefinedAndZero() {
     return LessGeneral(kind_, TruncationKind::kWord32) ||
            LessGeneral(kind_, TruncationKind::kBool);
   }
   bool IdentifiesUndefinedAndNaN() {
     return LessGeneral(kind_, TruncationKind::kFloat64) ||
            LessGeneral(kind_, TruncationKind::kWord64);
   }
   bool IdentifiesZeroAndMinusZero() const {
     return identify_zeros() == kIdentifyZeros;
   }

   // Operators.
   bool operator==(Truncation other) const {
     return kind() == other.kind() && identify_zeros() == other.identify_zeros();
   }
   bool operator!=(Truncation other) const { return !(*this == other); }

   // Debug utilities.
   const char* description() const;
   bool IsLessGeneralThan(Truncation other) {
     return LessGeneral(kind(), other.kind()) &&
            LessGeneralIdentifyZeros(identify_zeros(), other.identify_zeros());
   }

   IdentifyZeros identify_zeros() const { return identify_zeros_; }

  private:
   enum class TruncationKind : uint8_t {
     kNone,
     kBool,
     kWord32,
     kWord64,
     kFloat64,
     kAny
   };

   explicit Truncation(TruncationKind kind, IdentifyZeros identify_zeros)
       : kind_(kind), identify_zeros_(identify_zeros) {
     DCHECK(kind == TruncationKind::kAny || kind == TruncationKind::kFloat64 ||
            identify_zeros == kIdentifyZeros);
   }
   TruncationKind kind() const { return kind_; }

   TruncationKind kind_;
   IdentifyZeros identify_zeros_;

   static TruncationKind Generalize(TruncationKind rep1, TruncationKind rep2);
   static IdentifyZeros GeneralizeIdentifyZeros(IdentifyZeros i1,
                                                IdentifyZeros i2);
   static bool LessGeneral(TruncationKind rep1, TruncationKind rep2);
   static bool LessGeneralIdentifyZeros(IdentifyZeros u1, IdentifyZeros u2);
 };

 enum class TypeCheckKind : uint8_t {
   kNone,
   kSignedSmall,
   kSigned32,
   kNumber,
   kNumberOrOddball,
   kHeapObject
 };

 inline std::ostream& operator<<(std::ostream& os, TypeCheckKind type_check) {
   switch (type_check) {
     case TypeCheckKind::kNone:
       return os << "None";
     case TypeCheckKind::kSignedSmall:
       return os << "SignedSmall";
     case TypeCheckKind::kSigned32:
       return os << "Signed32";
     case TypeCheckKind::kNumber:
       return os << "Number";
     case TypeCheckKind::kNumberOrOddball:
       return os << "NumberOrOddball";
     case TypeCheckKind::kHeapObject:
       return os << "HeapObject";
   }
   UNREACHABLE();
 }

 // The {UseInfo} class is used to describe a use of an input of a node.
 //
 // This information is used in two different ways, based on the phase:
 //
 // 1. During propagation, the use info is used to inform the input node
 //    about what part of the input is used (we call this truncation) and what
 //    is the preferred representation. For conversions that will require
 //    checks, we also keep track of whether a minus zero check is needed.
 //
 // 2. During lowering, the use info is used to properly convert the input
 //    to the preferred representation. The preferred representation might be
 //    insufficient to do the conversion (e.g. word32->float64 conv), so we also
 //    need the signedness information to produce the correct value.
 //    Additionally, use info may contain {CheckParameters} which contains
 //    information for the deoptimizer such as a CallIC on which speculation
 //    should be disallowed if the check fails.
 class UseInfo {
  public:
   UseInfo(MachineRepresentation representation, Truncation truncation,
           TypeCheckKind type_check = TypeCheckKind::kNone,
           const VectorSlotPair& feedback = VectorSlotPair())
       : representation_(representation),
         truncation_(truncation),
         type_check_(type_check),
         feedback_(feedback) {}
   static UseInfo TruncatingWord32() {
     return UseInfo(MachineRepresentation::kWord32, Truncation::Word32());
   }
   static UseInfo TruncatingWord64() {
     return UseInfo(MachineRepresentation::kWord64, Truncation::Word64());
   }
   static UseInfo Bool() {
     return UseInfo(MachineRepresentation::kBit, Truncation::Bool());
   }
   static UseInfo Float32() {
     return UseInfo(MachineRepresentation::kFloat32, Truncation::Any());
   }
   static UseInfo TruncatingFloat64() {
     return UseInfo(MachineRepresentation::kFloat64, Truncation::Float64());
   }
   static UseInfo PointerInt() {
     return kPointerSize == 4 ? TruncatingWord32() : TruncatingWord64();
   }
   static UseInfo AnyTagged() {
     return UseInfo(MachineRepresentation::kTagged, Truncation::Any());
   }
   static UseInfo TaggedSigned() {
     return UseInfo(MachineRepresentation::kTaggedSigned, Truncation::Any());
   }
   static UseInfo TaggedPointer() {
     return UseInfo(MachineRepresentation::kTaggedPointer, Truncation::Any());
   }

   // Possibly deoptimizing conversions.
   static UseInfo CheckedHeapObjectAsTaggedPointer() {
     return UseInfo(MachineRepresentation::kTaggedPointer, Truncation::Any(),
                    TypeCheckKind::kHeapObject);
   }
   static UseInfo CheckedSignedSmallAsTaggedSigned(
       const VectorSlotPair& feedback) {
     return UseInfo(MachineRepresentation::kTaggedSigned, Truncation::Any(),
                    TypeCheckKind::kSignedSmall, feedback);
   }
   static UseInfo CheckedSignedSmallAsWord32(IdentifyZeros identify_zeros,
                                             const VectorSlotPair& feedback) {
     return UseInfo(MachineRepresentation::kWord32,
                    Truncation::Any(identify_zeros), TypeCheckKind::kSignedSmall,
                    feedback);
   }
   static UseInfo CheckedSigned32AsWord32(IdentifyZeros identify_zeros,
                                          const VectorSlotPair& feedback) {
     return UseInfo(MachineRepresentation::kWord32,
                    Truncation::Any(identify_zeros), TypeCheckKind::kSigned32,
                    feedback);
   }
   static UseInfo CheckedNumberAsFloat64(const VectorSlotPair& feedback) {
     return UseInfo(MachineRepresentation::kFloat64, Truncation::Any(),
                    TypeCheckKind::kNumber, feedback);
   }
   static UseInfo CheckedNumberAsWord32(const VectorSlotPair& feedback) {
     return UseInfo(MachineRepresentation::kWord32, Truncation::Word32(),
                    TypeCheckKind::kNumber, feedback);
   }
   static UseInfo CheckedNumberOrOddballAsFloat64(
       const VectorSlotPair& feedback) {
     return UseInfo(MachineRepresentation::kFloat64, Truncation::Any(),
                    TypeCheckKind::kNumberOrOddball, feedback);
   }
   static UseInfo CheckedNumberOrOddballAsWord32(
       const VectorSlotPair& feedback) {
     return UseInfo(MachineRepresentation::kWord32, Truncation::Word32(),
                    TypeCheckKind::kNumberOrOddball, feedback);
   }

   // Undetermined representation.
   static UseInfo Any() {
     return UseInfo(MachineRepresentation::kNone, Truncation::Any());
   }
   static UseInfo AnyTruncatingToBool() {
     return UseInfo(MachineRepresentation::kNone, Truncation::Bool());
   }

   // Value not used.
   static UseInfo None() {
     return UseInfo(MachineRepresentation::kNone, Truncation::None());
   }

   MachineRepresentation representation() const { return representation_; }
   Truncation truncation() const { return truncation_; }
   TypeCheckKind type_check() const { return type_check_; }
   CheckForMinusZeroMode minus_zero_check() const {
     return truncation().IdentifiesZeroAndMinusZero()
                ? CheckForMinusZeroMode::kDontCheckForMinusZero
                : CheckForMinusZeroMode::kCheckForMinusZero;
   }
   const VectorSlotPair& feedback() const { return feedback_; }

  private:
   MachineRepresentation representation_;
   Truncation truncation_;
   TypeCheckKind type_check_;
   VectorSlotPair feedback_;
 };

 // Contains logic related to changing the representation of values for constants
 // and other nodes, as well as lowering Simplified->Machine operators.
 // Eagerly folds any representation changes for constants.
 class RepresentationChanger final {
  public:
   RepresentationChanger(JSGraph* jsgraph, Isolate* isolate)
       : jsgraph_(jsgraph),
         isolate_(isolate),
         testing_type_errors_(false),
         type_error_(false) {}

   // Changes representation from {output_type} to {use_rep}. The {truncation}
   // parameter is only used for sanity checking - if the changer cannot figure
   // out signedness for the word32->float64 conversion, then we check that the
   // uses truncate to word32 (so they do not care about signedness).
   Node* GetRepresentationFor(Node* node, MachineRepresentation output_rep,
                              Type* output_type, Node* use_node,
                              UseInfo use_info);
   const Operator* Int32OperatorFor(IrOpcode::Value opcode);
   const Operator* Int32OverflowOperatorFor(IrOpcode::Value opcode);
   const Operator* TaggedSignedOperatorFor(IrOpcode::Value opcode);
   const Operator* Uint32OperatorFor(IrOpcode::Value opcode);
   const Operator* Uint32OverflowOperatorFor(IrOpcode::Value opcode);
   const Operator* Float64OperatorFor(IrOpcode::Value opcode);

   MachineType TypeForBasePointer(const FieldAccess& access) {
     return access.tag() != 0 ? MachineType::AnyTagged()
                              : MachineType::Pointer();
   }

   MachineType TypeForBasePointer(const ElementAccess& access) {
     return access.tag() != 0 ? MachineType::AnyTagged()
                              : MachineType::Pointer();
   }

  private:
   JSGraph* jsgraph_;
   Isolate* isolate_;

   friend class RepresentationChangerTester;  // accesses the below fields.

   bool testing_type_errors_;  // If {true}, don't abort on a type error.
   bool type_error_;           // Set when a type error is detected.

   Node* GetTaggedSignedRepresentationFor(Node* node,
                                          MachineRepresentation output_rep,
                                          Type* output_type, Node* use_node,
                                          UseInfo use_info);
   Node* GetTaggedPointerRepresentationFor(Node* node,
                                           MachineRepresentation output_rep,
                                           Type* output_type, Node* use_node,
                                           UseInfo use_info);
   Node* GetTaggedRepresentationFor(Node* node, MachineRepresentation output_rep,
                                    Type* output_type, Truncation truncation);
   Node* GetFloat32RepresentationFor(Node* node,
                                     MachineRepresentation output_rep,
                                     Type* output_type, Truncation truncation);
   Node* GetFloat64RepresentationFor(Node* node,
                                     MachineRepresentation output_rep,
                                     Type* output_type, Node* use_node,
                                     UseInfo use_info);
   Node* GetWord32RepresentationFor(Node* node, MachineRepresentation output_rep,
                                    Type* output_type, Node* use_node,
                                    UseInfo use_info);
   Node* GetBitRepresentationFor(Node* node, MachineRepresentation output_rep,
                                 Type* output_type);
   Node* GetWord64RepresentationFor(Node* node, MachineRepresentation output_rep,
                                    Type* output_type);
   Node* TypeError(Node* node, MachineRepresentation output_rep,
                   Type* output_type, MachineRepresentation use);
   Node* MakeTruncatedInt32Constant(double value);
   Node* InsertChangeBitToTagged(Node* node);
   Node* InsertChangeFloat32ToFloat64(Node* node);
   Node* InsertChangeFloat64ToInt32(Node* node);
   Node* InsertChangeFloat64ToUint32(Node* node);
   Node* InsertChangeInt32ToFloat64(Node* node);
   Node* InsertChangeTaggedSignedToInt32(Node* node);
   Node* InsertChangeTaggedToFloat64(Node* node);
   Node* InsertChangeUint32ToFloat64(Node* node);
   Node* InsertConversion(Node* node, const Operator* op, Node* use_node);
   void InsertUnconditionalDeopt(Node* node, DeoptimizeReason reason);

   JSGraph* jsgraph() const { return jsgraph_; }
   Isolate* isolate() const { return isolate_; }
   Factory* factory() const { return isolate()->factory(); }
   SimplifiedOperatorBuilder* simplified() { return jsgraph()->simplified(); }
   MachineOperatorBuilder* machine() { return jsgraph()->machine(); }
 };

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

 #endif  // V8_COMPILER_REPRESENTATION_CHANGE_H_
	// Copyright 2014 the V8 project authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#ifndef V8_COMPILER_REPRESENTATION_CHANGE_H_
	#define V8_COMPILER_REPRESENTATION_CHANGE_H_

	#include "src/compiler/js-graph.h"
	#include "src/compiler/simplified-operator.h"

	namespace v8 {
	namespace internal {
	namespace compiler {

	enum IdentifyZeros { kIdentifyZeros, kDistinguishZeros };

	class Truncation final {
	public:
	// Constructors.
	static Truncation None() {
	return Truncation(TruncationKind::kNone, kIdentifyZeros);
	}
	static Truncation Bool() {
	return Truncation(TruncationKind::kBool, kIdentifyZeros);
	}
	static Truncation Word32() {
	return Truncation(TruncationKind::kWord32, kIdentifyZeros);
	}
	static Truncation Word64() {
	return Truncation(TruncationKind::kWord64, kIdentifyZeros);
	}
	static Truncation Float64(IdentifyZeros identify_zeros = kDistinguishZeros) {
	return Truncation(TruncationKind::kFloat64, identify_zeros);
	}
	static Truncation Any(IdentifyZeros identify_zeros = kDistinguishZeros) {
	return Truncation(TruncationKind::kAny, identify_zeros);
	}

	static Truncation Generalize(Truncation t1, Truncation t2) {
	return Truncation(
	Generalize(t1.kind(), t2.kind()),
	GeneralizeIdentifyZeros(t1.identify_zeros(), t2.identify_zeros()));
	}

	// Queries.
	bool IsUnused() const { return kind_ == TruncationKind::kNone; }
	bool IsUsedAsBool() const {
	return LessGeneral(kind_, TruncationKind::kBool);
	}
	bool IsUsedAsWord32() const {
	return LessGeneral(kind_, TruncationKind::kWord32);
	}
	bool IsUsedAsFloat64() const {
	return LessGeneral(kind_, TruncationKind::kFloat64);
	}
	bool IdentifiesUndefinedAndZero() {
	return LessGeneral(kind_, TruncationKind::kWord32) \|\|
	LessGeneral(kind_, TruncationKind::kBool);
	}
	bool IdentifiesUndefinedAndNaN() {
	return LessGeneral(kind_, TruncationKind::kFloat64) \|\|
	LessGeneral(kind_, TruncationKind::kWord64);
	}
	bool IdentifiesZeroAndMinusZero() const {
	return identify_zeros() == kIdentifyZeros;
	}

	// Operators.
	bool operator==(Truncation other) const {
	return kind() == other.kind() && identify_zeros() == other.identify_zeros();
	}
	bool operator!=(Truncation other) const { return !(*this == other); }

	// Debug utilities.
	const char* description() const;
	bool IsLessGeneralThan(Truncation other) {
	return LessGeneral(kind(), other.kind()) &&
	LessGeneralIdentifyZeros(identify_zeros(), other.identify_zeros());
	}

	IdentifyZeros identify_zeros() const { return identify_zeros_; }

	private:
	enum class TruncationKind : uint8_t {
	kNone,
	kBool,
	kWord32,
	kWord64,
	kFloat64,
	kAny
	};

	explicit Truncation(TruncationKind kind, IdentifyZeros identify_zeros)
	: kind_(kind), identify_zeros_(identify_zeros) {
	DCHECK(kind == TruncationKind::kAny \|\| kind == TruncationKind::kFloat64 \|\|
	identify_zeros == kIdentifyZeros);
	}
	TruncationKind kind() const { return kind_; }

	TruncationKind kind_;
	IdentifyZeros identify_zeros_;

	static TruncationKind Generalize(TruncationKind rep1, TruncationKind rep2);
	static IdentifyZeros GeneralizeIdentifyZeros(IdentifyZeros i1,
	IdentifyZeros i2);
	static bool LessGeneral(TruncationKind rep1, TruncationKind rep2);
	static bool LessGeneralIdentifyZeros(IdentifyZeros u1, IdentifyZeros u2);
	};

	enum class TypeCheckKind : uint8_t {
	kNone,
	kSignedSmall,
	kSigned32,
	kNumber,
	kNumberOrOddball,
	kHeapObject
	};

	inline std::ostream& operator<<(std::ostream& os, TypeCheckKind type_check) {
	switch (type_check) {
	case TypeCheckKind::kNone:
	return os << "None";
	case TypeCheckKind::kSignedSmall:
	return os << "SignedSmall";
	case TypeCheckKind::kSigned32:
	return os << "Signed32";
	case TypeCheckKind::kNumber:
	return os << "Number";
	case TypeCheckKind::kNumberOrOddball:
	return os << "NumberOrOddball";
	case TypeCheckKind::kHeapObject:
	return os << "HeapObject";
	}
	UNREACHABLE();
	}

	// The {UseInfo} class is used to describe a use of an input of a node.
	//
	// This information is used in two different ways, based on the phase:
	//
	// 1. During propagation, the use info is used to inform the input node
	// about what part of the input is used (we call this truncation) and what
	// is the preferred representation. For conversions that will require
	// checks, we also keep track of whether a minus zero check is needed.
	//
	// 2. During lowering, the use info is used to properly convert the input
	// to the preferred representation. The preferred representation might be
	// insufficient to do the conversion (e.g. word32->float64 conv), so we also
	// need the signedness information to produce the correct value.
	// Additionally, use info may contain {CheckParameters} which contains
	// information for the deoptimizer such as a CallIC on which speculation
	// should be disallowed if the check fails.
	class UseInfo {
	public:
	UseInfo(MachineRepresentation representation, Truncation truncation,
	TypeCheckKind type_check = TypeCheckKind::kNone,
	const VectorSlotPair& feedback = VectorSlotPair())
	: representation_(representation),
	truncation_(truncation),
	type_check_(type_check),
	feedback_(feedback) {}
	static UseInfo TruncatingWord32() {
	return UseInfo(MachineRepresentation::kWord32, Truncation::Word32());
	}
	static UseInfo TruncatingWord64() {
	return UseInfo(MachineRepresentation::kWord64, Truncation::Word64());
	}
	static UseInfo Bool() {
	return UseInfo(MachineRepresentation::kBit, Truncation::Bool());
	}
	static UseInfo Float32() {
	return UseInfo(MachineRepresentation::kFloat32, Truncation::Any());
	}
	static UseInfo TruncatingFloat64() {
	return UseInfo(MachineRepresentation::kFloat64, Truncation::Float64());
	}
	static UseInfo PointerInt() {
	return kPointerSize == 4 ? TruncatingWord32() : TruncatingWord64();
	}
	static UseInfo AnyTagged() {
	return UseInfo(MachineRepresentation::kTagged, Truncation::Any());
	}
	static UseInfo TaggedSigned() {
	return UseInfo(MachineRepresentation::kTaggedSigned, Truncation::Any());
	}
	static UseInfo TaggedPointer() {
	return UseInfo(MachineRepresentation::kTaggedPointer, Truncation::Any());
	}

	// Possibly deoptimizing conversions.
	static UseInfo CheckedHeapObjectAsTaggedPointer() {
	return UseInfo(MachineRepresentation::kTaggedPointer, Truncation::Any(),
	TypeCheckKind::kHeapObject);
	}
	static UseInfo CheckedSignedSmallAsTaggedSigned(
	const VectorSlotPair& feedback) {
	return UseInfo(MachineRepresentation::kTaggedSigned, Truncation::Any(),
	TypeCheckKind::kSignedSmall, feedback);
	}
	static UseInfo CheckedSignedSmallAsWord32(IdentifyZeros identify_zeros,
	const VectorSlotPair& feedback) {
	return UseInfo(MachineRepresentation::kWord32,
	Truncation::Any(identify_zeros), TypeCheckKind::kSignedSmall,
	feedback);
	}
	static UseInfo CheckedSigned32AsWord32(IdentifyZeros identify_zeros,
	const VectorSlotPair& feedback) {
	return UseInfo(MachineRepresentation::kWord32,
	Truncation::Any(identify_zeros), TypeCheckKind::kSigned32,
	feedback);
	}
	static UseInfo CheckedNumberAsFloat64(const VectorSlotPair& feedback) {
	return UseInfo(MachineRepresentation::kFloat64, Truncation::Any(),
	TypeCheckKind::kNumber, feedback);
	}
	static UseInfo CheckedNumberAsWord32(const VectorSlotPair& feedback) {
	return UseInfo(MachineRepresentation::kWord32, Truncation::Word32(),
	TypeCheckKind::kNumber, feedback);
	}
	static UseInfo CheckedNumberOrOddballAsFloat64(
	const VectorSlotPair& feedback) {
	return UseInfo(MachineRepresentation::kFloat64, Truncation::Any(),
	TypeCheckKind::kNumberOrOddball, feedback);
	}
	static UseInfo CheckedNumberOrOddballAsWord32(
	const VectorSlotPair& feedback) {
	return UseInfo(MachineRepresentation::kWord32, Truncation::Word32(),
	TypeCheckKind::kNumberOrOddball, feedback);
	}

	// Undetermined representation.
	static UseInfo Any() {
	return UseInfo(MachineRepresentation::kNone, Truncation::Any());
	}
	static UseInfo AnyTruncatingToBool() {
	return UseInfo(MachineRepresentation::kNone, Truncation::Bool());
	}

	// Value not used.
	static UseInfo None() {
	return UseInfo(MachineRepresentation::kNone, Truncation::None());
	}

	MachineRepresentation representation() const { return representation_; }
	Truncation truncation() const { return truncation_; }
	TypeCheckKind type_check() const { return type_check_; }
	CheckForMinusZeroMode minus_zero_check() const {
	return truncation().IdentifiesZeroAndMinusZero()
	? CheckForMinusZeroMode::kDontCheckForMinusZero
	: CheckForMinusZeroMode::kCheckForMinusZero;
	}
	const VectorSlotPair& feedback() const { return feedback_; }

	private:
	MachineRepresentation representation_;
	Truncation truncation_;
	TypeCheckKind type_check_;
	VectorSlotPair feedback_;
	};

	// Contains logic related to changing the representation of values for constants
	// and other nodes, as well as lowering Simplified->Machine operators.
	// Eagerly folds any representation changes for constants.
	class RepresentationChanger final {
	public:
	RepresentationChanger(JSGraph* jsgraph, Isolate* isolate)
	: jsgraph_(jsgraph),
	isolate_(isolate),
	testing_type_errors_(false),
	type_error_(false) {}

	// Changes representation from {output_type} to {use_rep}. The {truncation}
	// parameter is only used for sanity checking - if the changer cannot figure
	// out signedness for the word32->float64 conversion, then we check that the
	// uses truncate to word32 (so they do not care about signedness).
	Node* GetRepresentationFor(Node* node, MachineRepresentation output_rep,
	Type* output_type, Node* use_node,
	UseInfo use_info);
	const Operator* Int32OperatorFor(IrOpcode::Value opcode);
	const Operator* Int32OverflowOperatorFor(IrOpcode::Value opcode);
	const Operator* TaggedSignedOperatorFor(IrOpcode::Value opcode);
	const Operator* Uint32OperatorFor(IrOpcode::Value opcode);
	const Operator* Uint32OverflowOperatorFor(IrOpcode::Value opcode);
	const Operator* Float64OperatorFor(IrOpcode::Value opcode);

	MachineType TypeForBasePointer(const FieldAccess& access) {
	return access.tag() != 0 ? MachineType::AnyTagged()
	: MachineType::Pointer();
	}

	MachineType TypeForBasePointer(const ElementAccess& access) {
	return access.tag() != 0 ? MachineType::AnyTagged()
	: MachineType::Pointer();
	}

	private:
	JSGraph* jsgraph_;
	Isolate* isolate_;

	friend class RepresentationChangerTester; // accesses the below fields.

	bool testing_type_errors_; // If {true}, don't abort on a type error.
	bool type_error_; // Set when a type error is detected.

	Node* GetTaggedSignedRepresentationFor(Node* node,
	MachineRepresentation output_rep,
	Type* output_type, Node* use_node,
	UseInfo use_info);
	Node* GetTaggedPointerRepresentationFor(Node* node,
	MachineRepresentation output_rep,
	Type* output_type, Node* use_node,
	UseInfo use_info);
	Node* GetTaggedRepresentationFor(Node* node, MachineRepresentation output_rep,
	Type* output_type, Truncation truncation);
	Node* GetFloat32RepresentationFor(Node* node,
	MachineRepresentation output_rep,
	Type* output_type, Truncation truncation);
	Node* GetFloat64RepresentationFor(Node* node,
	MachineRepresentation output_rep,
	Type* output_type, Node* use_node,
	UseInfo use_info);
	Node* GetWord32RepresentationFor(Node* node, MachineRepresentation output_rep,
	Type* output_type, Node* use_node,
	UseInfo use_info);
	Node* GetBitRepresentationFor(Node* node, MachineRepresentation output_rep,
	Type* output_type);
	Node* GetWord64RepresentationFor(Node* node, MachineRepresentation output_rep,
	Type* output_type);
	Node* TypeError(Node* node, MachineRepresentation output_rep,
	Type* output_type, MachineRepresentation use);
	Node* MakeTruncatedInt32Constant(double value);
	Node* InsertChangeBitToTagged(Node* node);
	Node* InsertChangeFloat32ToFloat64(Node* node);
	Node* InsertChangeFloat64ToInt32(Node* node);
	Node* InsertChangeFloat64ToUint32(Node* node);
	Node* InsertChangeInt32ToFloat64(Node* node);
	Node* InsertChangeTaggedSignedToInt32(Node* node);
	Node* InsertChangeTaggedToFloat64(Node* node);
	Node* InsertChangeUint32ToFloat64(Node* node);
	Node* InsertConversion(Node* node, const Operator* op, Node* use_node);
	void InsertUnconditionalDeopt(Node* node, DeoptimizeReason reason);

	JSGraph* jsgraph() const { return jsgraph_; }
	Isolate* isolate() const { return isolate_; }
	Factory* factory() const { return isolate()->factory(); }
	SimplifiedOperatorBuilder* simplified() { return jsgraph()->simplified(); }
	MachineOperatorBuilder* machine() { return jsgraph()->machine(); }
	};

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

	#endif // V8_COMPILER_REPRESENTATION_CHANGE_H_