Revert of [turbofan] Remove left-over change bits from ChangeLowering....

Revert of [turbofan] Remove left-over change bits from ChangeLowering. (patchset #2 id:20001 of https://codereview.chromium.org/1941673002/ )

Reason for revert:
[Sheriff] Breaks mac gc stress:
https://build.chromium.org/p/client.v8/builders/V8%20Mac%20GC%20Stress/builds/5821

Original issue's description:
> [turbofan] Remove left-over change bits from ChangeLowering.
>
> Now ChangeLowering is only concerned with lowering memory access and
> allocation operations, and all changes are consistently lowered during
> the effect/control linearization pass. The next step is to move the
> left over lowerings to a pass dedicated to eliminate redundant loads and
> stores, eliminate write barriers, fold and inline allocations.
>
> Also remove the atomic regions now that we wire everything into the
> effect chain properly. This is an important step towards allocation
> inlining.
>
> Drive-by-fix: Rename ChangeBitToBool to ChangeBitToTagged,
> ChangeBoolToBit to ChangeTaggedToBit, and ChangeInt31ToTagged to
> ChangeInt31ToTaggedSigned for consistency.
>
> CQ_INCLUDE_TRYBOTS=tryserver.v8:v8_linux64_tsan_rel
>
> Committed: https://crrev.com/ceca5ae308bddda166651c654f96d71d74f617d0
> Cr-Commit-Position: refs/heads/master@{#35924}

TBR=ishell@chromium.org,bmeurer@chromium.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Review-Url: https://codereview.chromium.org/1942733002
Cr-Commit-Position: refs/heads/master@{#35927}

src/compiler/change-lowering.cc

@@ -4,12 +4,14 @@
 
 #include "src/compiler/change-lowering.h"
 
+#include "src/address-map.h"
+#include "src/code-factory.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-properties.h"
+#include "src/compiler/operator-properties.h"
 #include "src/compiler/simplified-operator.h"
-#include "src/conversions-inl.h"
 
 namespace v8 {
 namespace internal {
@@ -19,7 +21,16 @@ ChangeLowering::~ChangeLowering() {}
 
 
 Reduction ChangeLowering::Reduce(Node* node) {
+  Node* control = graph()->start();
   switch (node->opcode()) {
+    case IrOpcode::kChangeBitToBool:
+      return ReduceChangeBitToBool(node->InputAt(0), control);
+    case IrOpcode::kChangeBoolToBit:
+      return ReduceChangeBoolToBit(node->InputAt(0));
+    case IrOpcode::kChangeInt31ToTagged:
+      return ReduceChangeInt31ToTagged(node->InputAt(0), control);
+    case IrOpcode::kChangeTaggedSignedToInt32:
+      return ReduceChangeTaggedSignedToInt32(node->InputAt(0));
     case IrOpcode::kLoadField:
       return ReduceLoadField(node);
     case IrOpcode::kStoreField:
@@ -30,6 +41,8 @@ Reduction ChangeLowering::Reduce(Node* node) {
       return ReduceStoreElement(node);
     case IrOpcode::kAllocate:
       return ReduceAllocate(node);
+    case IrOpcode::kObjectIsSmi:
+      return ReduceObjectIsSmi(node);
     default:
       return NoChange();
   }
@@ -37,6 +50,50 @@ Reduction ChangeLowering::Reduce(Node* node) {
   return NoChange();
 }
 
+Node* ChangeLowering::SmiShiftBitsConstant() {
+  return jsgraph()->IntPtrConstant(kSmiShiftSize + kSmiTagSize);
+}
+
+Node* ChangeLowering::ChangeInt32ToSmi(Node* value) {
+  if (machine()->Is64()) {
+    value = graph()->NewNode(machine()->ChangeInt32ToInt64(), value);
+  }
+  return graph()->NewNode(machine()->WordShl(), value, SmiShiftBitsConstant());
+}
+
+Node* ChangeLowering::ChangeSmiToWord32(Node* value) {
+  value = graph()->NewNode(machine()->WordSar(), value, SmiShiftBitsConstant());
+  if (machine()->Is64()) {
+    value = graph()->NewNode(machine()->TruncateInt64ToInt32(), value);
+  }
+  return value;
+}
+
+
+Node* ChangeLowering::ChangeUint32ToFloat64(Node* value) {
+  return graph()->NewNode(machine()->ChangeUint32ToFloat64(), value);
+}
+
+Reduction ChangeLowering::ReduceChangeBitToBool(Node* value, Node* control) {
+  return Replace(
+      graph()->NewNode(common()->Select(MachineRepresentation::kTagged), value,
+                       jsgraph()->TrueConstant(), jsgraph()->FalseConstant()));
+}
+
+Reduction ChangeLowering::ReduceChangeBoolToBit(Node* value) {
+  return Replace(graph()->NewNode(machine()->WordEqual(), value,
+                                  jsgraph()->TrueConstant()));
+}
+
+Reduction ChangeLowering::ReduceChangeInt31ToTagged(Node* value,
+                                                    Node* control) {
+  return Replace(ChangeInt32ToSmi(value));
+}
+
+Reduction ChangeLowering::ReduceChangeTaggedSignedToInt32(Node* value) {
+  return Replace(ChangeSmiToWord32(value));
+}
+
 namespace {
 
 WriteBarrierKind ComputeWriteBarrierKind(BaseTaggedness base_is_tagged,
@@ -148,6 +205,15 @@ Reduction ChangeLowering::ReduceAllocate(Node* node) {
   return Changed(node);
 }
 
+Reduction ChangeLowering::ReduceObjectIsSmi(Node* node) {
+  node->ReplaceInput(0,
+                     graph()->NewNode(machine()->WordAnd(), node->InputAt(0),
+                                      jsgraph()->IntPtrConstant(kSmiTagMask)));
+  node->AppendInput(graph()->zone(), jsgraph()->IntPtrConstant(kSmiTag));
+  NodeProperties::ChangeOp(node, machine()->WordEqual());
+  return Changed(node);
+}
+
 Isolate* ChangeLowering::isolate() const { return jsgraph()->isolate(); }
 
 

src/compiler/change-lowering.h

@@ -27,12 +27,25 @@ class ChangeLowering final : public Reducer {
   Reduction Reduce(Node* node) final;
 
  private:
+  Node* SmiShiftBitsConstant();
+
+  Node* ChangeInt32ToSmi(Node* value);
+  Node* ChangeSmiToWord32(Node* value);
+  Node* ChangeUint32ToFloat64(Node* value);
+
+  Reduction ReduceChangeBitToBool(Node* value, Node* control);
+  Reduction ReduceChangeBoolToBit(Node* value);
+  Reduction ReduceChangeInt31ToTagged(Node* value, Node* control);
+  Reduction ReduceChangeTaggedSignedToInt32(Node* value);
+
   Reduction ReduceLoadField(Node* node);
   Reduction ReduceStoreField(Node* node);
   Reduction ReduceLoadElement(Node* node);
   Reduction ReduceStoreElement(Node* node);
   Reduction ReduceAllocate(Node* node);
 
+  Reduction ReduceObjectIsSmi(Node* node);
+
   Node* ComputeIndex(const ElementAccess& access, Node* const key);
   Graph* graph() const;
   Isolate* isolate() const;

src/compiler/effect-control-linearizer.h

@@ -41,20 +41,12 @@ class EffectControlLinearizer {
   };
 
   bool TryWireInStateEffect(Node* node, Node** effect, Node** control);
-  ValueEffectControl LowerChangeBitToTagged(Node* node, Node* effect,
-                                            Node* control);
-  ValueEffectControl LowerChangeInt31ToTaggedSigned(Node* node, Node* effect,
-                                                    Node* control);
   ValueEffectControl LowerChangeInt32ToTagged(Node* node, Node* effect,
                                               Node* control);
   ValueEffectControl LowerChangeUint32ToTagged(Node* node, Node* effect,
                                                Node* control);
   ValueEffectControl LowerChangeFloat64ToTagged(Node* node, Node* effect,
                                                 Node* control);
-  ValueEffectControl LowerChangeTaggedSignedToInt32(Node* node, Node* effect,
-                                                    Node* control);
-  ValueEffectControl LowerChangeTaggedToBit(Node* node, Node* effect,
-                                            Node* control);
   ValueEffectControl LowerChangeTaggedToInt32(Node* node, Node* effect,
                                               Node* control);
   ValueEffectControl LowerChangeTaggedToUint32(Node* node, Node* effect,
@@ -69,7 +61,6 @@ class EffectControlLinearizer {
                                          Node* control);
   ValueEffectControl LowerObjectIsReceiver(Node* node, Node* effect,
                                            Node* control);
-  ValueEffectControl LowerObjectIsSmi(Node* node, Node* effect, Node* control);
   ValueEffectControl LowerObjectIsString(Node* node, Node* effect,
                                          Node* control);
   ValueEffectControl LowerObjectIsUndetectable(Node* node, Node* effect,
@@ -81,8 +72,6 @@ class EffectControlLinearizer {
   Node* ChangeUint32ToSmi(Node* value);
   Node* ChangeInt32ToFloat64(Node* value);
   Node* ChangeUint32ToFloat64(Node* value);
-  Node* ChangeSmiToInt32(Node* value);
-  Node* ObjectIsSmi(Node* value);
 
   Node* SmiMaxValueConstant();
   Node* SmiShiftBitsConstant();

src/compiler/opcodes.h

@@ -200,12 +200,12 @@
   V(ChangeTaggedToInt32)           \
   V(ChangeTaggedToUint32)          \
   V(ChangeTaggedToFloat64)         \
-  V(ChangeInt31ToTaggedSigned)     \
+  V(ChangeInt31ToTagged)           \
   V(ChangeInt32ToTagged)           \
   V(ChangeUint32ToTagged)          \
   V(ChangeFloat64ToTagged)         \
-  V(ChangeTaggedToBit)             \
-  V(ChangeBitToTagged)             \
+  V(ChangeBoolToBit)               \
+  V(ChangeBitToBool)               \
   V(TruncateTaggedToWord32)        \
   V(Allocate)                      \
   V(LoadField)                     \

src/compiler/representation-change.cc

@@ -188,10 +188,10 @@ Node* RepresentationChanger::GetTaggedRepresentationFor(
   // Select the correct X -> Tagged operator.
   const Operator* op;
   if (output_rep == MachineRepresentation::kBit) {
-    op = simplified()->ChangeBitToTagged();
+    op = simplified()->ChangeBitToBool();
   } else if (IsWord(output_rep)) {
     if (output_type->Is(Type::Signed31())) {
-      op = simplified()->ChangeInt31ToTaggedSigned();
+      op = simplified()->ChangeInt31ToTagged();
     } else if (output_type->Is(Type::Signed32())) {
       op = simplified()->ChangeInt32ToTagged();
     } else if (output_type->Is(Type::Unsigned32())) {
@@ -208,7 +208,7 @@ Node* RepresentationChanger::GetTaggedRepresentationFor(
   } else if (output_rep == MachineRepresentation::kFloat64) {
     if (output_type->Is(Type::Signed31())) {  // float64 -> int32 -> tagged
       node = InsertChangeFloat64ToInt32(node);
-      op = simplified()->ChangeInt31ToTaggedSigned();
+      op = simplified()->ChangeInt31ToTagged();
     } else if (output_type->Is(
                    Type::Signed32())) {  // float64 -> int32 -> tagged
       node = InsertChangeFloat64ToInt32(node);
@@ -418,7 +418,7 @@ Node* RepresentationChanger::GetBitRepresentationFor(
   // Select the correct X -> Bit operator.
   const Operator* op;
   if (output_rep == MachineRepresentation::kTagged) {
-    op = simplified()->ChangeTaggedToBit();
+    op = simplified()->ChangeBoolToBit();
   } else {
     return TypeError(node, output_rep, output_type,
                      MachineRepresentation::kBit);

src/compiler/simplified-operator-reducer.cc

@@ -31,17 +31,17 @@ Reduction SimplifiedOperatorReducer::Reduce(Node* node) {
       if (m.IsBooleanNot()) return Replace(m.InputAt(0));
       break;
     }
-    case IrOpcode::kChangeBitToTagged: {
+    case IrOpcode::kChangeBitToBool: {
       Int32Matcher m(node->InputAt(0));
       if (m.Is(0)) return Replace(jsgraph()->FalseConstant());
       if (m.Is(1)) return Replace(jsgraph()->TrueConstant());
-      if (m.IsChangeTaggedToBit()) return Replace(m.InputAt(0));
+      if (m.IsChangeBoolToBit()) return Replace(m.InputAt(0));
       break;
     }
-    case IrOpcode::kChangeTaggedToBit: {
+    case IrOpcode::kChangeBoolToBit: {
       HeapObjectMatcher m(node->InputAt(0));
       if (m.HasValue()) return ReplaceInt32(m.Value()->BooleanValue());
-      if (m.IsChangeBitToTagged()) return Replace(m.InputAt(0));
+      if (m.IsChangeBitToBool()) return Replace(m.InputAt(0));
       break;
     }
     case IrOpcode::kChangeFloat64ToTagged: {
@@ -50,7 +50,7 @@ Reduction SimplifiedOperatorReducer::Reduce(Node* node) {
       if (m.IsChangeTaggedToFloat64()) return Replace(m.node()->InputAt(0));
       break;
     }
-    case IrOpcode::kChangeInt31ToTaggedSigned:
+    case IrOpcode::kChangeInt31ToTagged:
     case IrOpcode::kChangeInt32ToTagged: {
       Int32Matcher m(node->InputAt(0));
       if (m.HasValue()) return ReplaceNumber(m.Value());
@@ -63,7 +63,7 @@ Reduction SimplifiedOperatorReducer::Reduce(Node* node) {
       NumberMatcher m(node->InputAt(0));
       if (m.HasValue()) return ReplaceFloat64(m.Value());
       if (m.IsChangeFloat64ToTagged()) return Replace(m.node()->InputAt(0));
-      if (m.IsChangeInt31ToTaggedSigned() || m.IsChangeInt32ToTagged()) {
+      if (m.IsChangeInt31ToTagged() || m.IsChangeInt32ToTagged()) {
         return Change(node, machine()->ChangeInt32ToFloat64(), m.InputAt(0));
       }
       if (m.IsChangeUint32ToTagged()) {
@@ -77,7 +77,7 @@ Reduction SimplifiedOperatorReducer::Reduce(Node* node) {
       if (m.IsChangeFloat64ToTagged()) {
         return Change(node, machine()->ChangeFloat64ToInt32(), m.InputAt(0));
       }
-      if (m.IsChangeInt31ToTaggedSigned() || m.IsChangeInt32ToTagged()) {
+      if (m.IsChangeInt31ToTagged() || m.IsChangeInt32ToTagged()) {
         return Replace(m.InputAt(0));
       }
       break;
@@ -99,7 +99,7 @@ Reduction SimplifiedOperatorReducer::Reduce(Node* node) {
     case IrOpcode::kTruncateTaggedToWord32: {
       NumberMatcher m(node->InputAt(0));
       if (m.HasValue()) return ReplaceInt32(DoubleToInt32(m.Value()));
-      if (m.IsChangeInt31ToTaggedSigned() || m.IsChangeInt32ToTagged() ||
+      if (m.IsChangeInt31ToTagged() || m.IsChangeInt32ToTagged() ||
           m.IsChangeUint32ToTagged()) {
         return Replace(m.InputAt(0));
       }

src/compiler/simplified-operator.cc

@@ -186,12 +186,12 @@ const ElementAccess& ElementAccessOf(const Operator* op) {
   V(ChangeTaggedToInt32, Operator::kNoProperties, 1)       \
   V(ChangeTaggedToUint32, Operator::kNoProperties, 1)      \
   V(ChangeTaggedToFloat64, Operator::kNoProperties, 1)     \
-  V(ChangeInt31ToTaggedSigned, Operator::kNoProperties, 1) \
+  V(ChangeInt31ToTagged, Operator::kNoProperties, 1)       \
   V(ChangeInt32ToTagged, Operator::kNoProperties, 1)       \
   V(ChangeUint32ToTagged, Operator::kNoProperties, 1)      \
   V(ChangeFloat64ToTagged, Operator::kNoProperties, 1)     \
-  V(ChangeTaggedToBit, Operator::kNoProperties, 1)         \
-  V(ChangeBitToTagged, Operator::kNoProperties, 1)         \
+  V(ChangeBoolToBit, Operator::kNoProperties, 1)           \
+  V(ChangeBitToBool, Operator::kNoProperties, 1)           \
   V(TruncateTaggedToWord32, Operator::kNoProperties, 1)    \
   V(ObjectIsCallable, Operator::kNoProperties, 1)          \
   V(ObjectIsNumber, Operator::kNoProperties, 1)            \

src/compiler/simplified-operator.h

@@ -163,12 +163,12 @@ class SimplifiedOperatorBuilder final : public ZoneObject {
   const Operator* ChangeTaggedToInt32();
   const Operator* ChangeTaggedToUint32();
   const Operator* ChangeTaggedToFloat64();
-  const Operator* ChangeInt31ToTaggedSigned();
+  const Operator* ChangeInt31ToTagged();
   const Operator* ChangeInt32ToTagged();
   const Operator* ChangeUint32ToTagged();
   const Operator* ChangeFloat64ToTagged();
-  const Operator* ChangeTaggedToBit();
-  const Operator* ChangeBitToTagged();
+  const Operator* ChangeBoolToBit();
+  const Operator* ChangeBitToBool();
   const Operator* TruncateTaggedToWord32();
 
   const Operator* ObjectIsCallable();

src/compiler/typer.cc

@@ -1871,7 +1871,7 @@ Type* Typer::Visitor::TypeChangeTaggedToFloat64(Node* node) {
   return ChangeRepresentation(arg, Type::UntaggedFloat64(), zone());
 }
 
-Type* Typer::Visitor::TypeChangeInt31ToTaggedSigned(Node* node) {
+Type* Typer::Visitor::TypeChangeInt31ToTagged(Node* node) {
   Type* arg = Operand(node, 0);
   // TODO(neis): DCHECK(arg->Is(Type::Signed31()));
   Type* rep =
@@ -1901,13 +1901,15 @@ Type* Typer::Visitor::TypeChangeFloat64ToTagged(Node* node) {
   return ChangeRepresentation(arg, Type::Tagged(), zone());
 }
 
-Type* Typer::Visitor::TypeChangeTaggedToBit(Node* node) {
+
+Type* Typer::Visitor::TypeChangeBoolToBit(Node* node) {
   Type* arg = Operand(node, 0);
   // TODO(neis): DCHECK(arg.upper->Is(Type::Boolean()));
   return ChangeRepresentation(arg, Type::UntaggedBit(), zone());
 }
 
-Type* Typer::Visitor::TypeChangeBitToTagged(Node* node) {
+
+Type* Typer::Visitor::TypeChangeBitToBool(Node* node) {
   Type* arg = Operand(node, 0);
   // TODO(neis): DCHECK(arg.upper->Is(Type::Boolean()));
   return ChangeRepresentation(arg, Type::TaggedPointer(), zone());

src/compiler/verifier.cc

@@ -803,7 +803,7 @@ void Verifier::Visitor::Check(Node* node) {
       // CheckUpperIs(node, to));
       break;
     }
-    case IrOpcode::kChangeInt31ToTaggedSigned: {
+    case IrOpcode::kChangeInt31ToTagged: {
       // Signed31 /\ UntaggedInt32 -> Signed31 /\ Tagged
       // TODO(neis): Activate once ChangeRepresentation works in typer.
       // Type* from =Type::Intersect(Type::Signed31(), Type::UntaggedInt32());
@@ -839,7 +839,7 @@ void Verifier::Visitor::Check(Node* node) {
       // CheckUpperIs(node, to));
       break;
     }
-    case IrOpcode::kChangeTaggedToBit: {
+    case IrOpcode::kChangeBoolToBit: {
       // Boolean /\ TaggedPtr -> Boolean /\ UntaggedInt1
       // TODO(neis): Activate once ChangeRepresentation works in typer.
       // Type* from = Type::Intersect(Type::Boolean(), Type::TaggedPtr());
@@ -848,7 +848,7 @@ void Verifier::Visitor::Check(Node* node) {
       // CheckUpperIs(node, to));
       break;
     }
-    case IrOpcode::kChangeBitToTagged: {
+    case IrOpcode::kChangeBitToBool: {
       // Boolean /\ UntaggedInt1 -> Boolean /\ TaggedPtr
       // TODO(neis): Activate once ChangeRepresentation works in typer.
       // Type* from = Type::Intersect(Type::Boolean(), Type::UntaggedInt1());

test/cctest/cctest.gyp

@@ -51,6 +51,7 @@
         'compiler/graph-builder-tester.h',
         'compiler/test-basic-block-profiler.cc',
         'compiler/test-branch-combine.cc',
+        'compiler/test-changes-lowering.cc',
         'compiler/test-code-stub-assembler.cc',
         'compiler/test-gap-resolver.cc',
         'compiler/test-graph-visualizer.cc',

test/cctest/compiler/graph-builder-tester.h

@@ -168,11 +168,11 @@ class GraphBuilderTester : public HandleAndZoneScope,
   Node* ChangeFloat64ToTagged(Node* a) {
     return NewNode(simplified()->ChangeFloat64ToTagged(), a);
   }
-  Node* ChangeTaggedToBit(Node* a) {
-    return NewNode(simplified()->ChangeTaggedToBit(), a);
+  Node* ChangeBoolToBit(Node* a) {
+    return NewNode(simplified()->ChangeBoolToBit(), a);
   }
-  Node* ChangeBitToTagged(Node* a) {
-    return NewNode(simplified()->ChangeBitToTagged(), a);
+  Node* ChangeBitToBool(Node* a) {
+    return NewNode(simplified()->ChangeBitToBool(), a);
   }
 
   Node* LoadField(const FieldAccess& access, Node* object) {

test/cctest/compiler/test-changes-lowering.cc

+// 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.
+
+#include <limits>
+
+#include "src/ast/scopes.h"
+#include "src/compiler/change-lowering.h"
+#include "src/compiler/control-builders.h"
+#include "src/compiler/js-graph.h"
+#include "src/compiler/node-properties.h"
+#include "src/compiler/pipeline.h"
+#include "src/compiler/select-lowering.h"
+#include "src/compiler/simplified-lowering.h"
+#include "src/compiler/typer.h"
+#include "src/compiler/verifier.h"
+#include "src/execution.h"
+#include "src/globals.h"
+#include "src/parsing/parser.h"
+#include "src/parsing/rewriter.h"
+#include "test/cctest/cctest.h"
+#include "test/cctest/compiler/codegen-tester.h"
+#include "test/cctest/compiler/function-tester.h"
+#include "test/cctest/compiler/graph-builder-tester.h"
+#include "test/cctest/compiler/value-helper.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+template <typename ReturnType>
+class ChangesLoweringTester : public GraphBuilderTester<ReturnType> {
+ public:
+  explicit ChangesLoweringTester(MachineType p0 = MachineType::None())
+      : GraphBuilderTester<ReturnType>(p0),
+        javascript(this->zone()),
+        jsgraph(this->isolate(), this->graph(), this->common(), &javascript,
+                nullptr, this->machine()),
+        function(Handle<JSFunction>::null()) {}
+
+  JSOperatorBuilder javascript;
+  JSGraph jsgraph;
+  Handle<JSFunction> function;
+
+  Node* start() { return this->graph()->start(); }
+
+  template <typename T>
+  T* CallWithPotentialGC() {
+    // TODO(titzer): we wrap the code in a JSFunction here to reuse the
+    // JSEntryStub; that could be done with a special prologue or other stub.
+    if (function.is_null()) {
+      function = FunctionTester::ForMachineGraph(this->graph());
+    }
+    Handle<Object>* args = NULL;
+    MaybeHandle<Object> result =
+        Execution::Call(this->isolate(), function, factory()->undefined_value(),
+                        0, args, false);
+    return T::cast(*result.ToHandleChecked());
+  }
+
+  void StoreFloat64(Node* node, double* ptr) {
+    Node* ptr_node = this->PointerConstant(ptr);
+    this->Store(MachineType::Float64(), ptr_node, node);
+  }
+
+  Node* LoadInt32(int32_t* ptr) {
+    Node* ptr_node = this->PointerConstant(ptr);
+    return this->Load(MachineType::Int32(), ptr_node);
+  }
+
+  Node* LoadUint32(uint32_t* ptr) {
+    Node* ptr_node = this->PointerConstant(ptr);
+    return this->Load(MachineType::Uint32(), ptr_node);
+  }
+
+  Node* LoadFloat64(double* ptr) {
+    Node* ptr_node = this->PointerConstant(ptr);
+    return this->Load(MachineType::Float64(), ptr_node);
+  }
+
+  void CheckNumber(double expected, Object* number) {
+    CHECK(this->isolate()->factory()->NewNumber(expected)->SameValue(number));
+  }
+
+  void BuildAndLower(const Operator* op) {
+    // We build a graph by hand here, because the raw machine assembler
+    // does not add the correct control and effect nodes.
+    Node* p0 = this->Parameter(0);
+    Node* change = this->graph()->NewNode(op, p0);
+    Node* ret = this->graph()->NewNode(this->common()->Return(), change,
+                                       this->start(), this->start());
+    Node* end = this->graph()->NewNode(this->common()->End(1), ret);
+    this->graph()->SetEnd(end);
+    LowerChange(change);
+  }
+
+  void BuildStoreAndLower(const Operator* op, const Operator* store_op,
+                          void* location) {
+    // We build a graph by hand here, because the raw machine assembler
+    // does not add the correct control and effect nodes.
+    Node* p0 = this->Parameter(0);
+    Node* change = this->graph()->NewNode(op, p0);
+    Node* store = this->graph()->NewNode(
+        store_op, this->PointerConstant(location), this->Int32Constant(0),
+        change, this->start(), this->start());
+    Node* ret = this->graph()->NewNode(
+        this->common()->Return(), this->Int32Constant(0), store, this->start());
+    Node* end = this->graph()->NewNode(this->common()->End(1), ret);
+    this->graph()->SetEnd(end);
+    LowerChange(change);
+  }
+
+  void BuildLoadAndLower(const Operator* op, const Operator* load_op,
+                         void* location) {
+    // We build a graph by hand here, because the raw machine assembler
+    // does not add the correct control and effect nodes.
+    Node* load = this->graph()->NewNode(
+        load_op, this->PointerConstant(location), this->Int32Constant(0),
+        this->start(), this->start());
+    Node* change = this->graph()->NewNode(op, load);
+    Node* ret = this->graph()->NewNode(this->common()->Return(), change,
+                                       this->start(), this->start());
+    Node* end = this->graph()->NewNode(this->common()->End(1), ret);
+    this->graph()->SetEnd(end);
+    LowerChange(change);
+  }
+
+  void LowerChange(Node* change) {
+    // Run the graph reducer with changes lowering on a single node.
+    Typer typer(this->isolate(), this->graph());
+    typer.Run();
+    ChangeLowering change_lowering(&jsgraph);
+    SelectLowering select_lowering(this->graph(), this->common());
+    GraphReducer reducer(this->zone(), this->graph());
+    reducer.AddReducer(&change_lowering);
+    reducer.AddReducer(&select_lowering);
+    reducer.ReduceNode(change);
+    Verifier::Run(this->graph(), Verifier::UNTYPED);
+  }
+
+  Factory* factory() { return this->isolate()->factory(); }
+  Heap* heap() { return this->isolate()->heap(); }
+};
+
+
+TEST(RunChangeBoolToBit) {
+  ChangesLoweringTester<int32_t> t(MachineType::AnyTagged());
+  t.BuildAndLower(t.simplified()->ChangeBoolToBit());
+
+  {
+    Object* true_obj = t.heap()->true_value();
+    int32_t result = t.Call(true_obj);
+    CHECK_EQ(1, result);
+  }
+
+  {
+    Object* false_obj = t.heap()->false_value();
+    int32_t result = t.Call(false_obj);
+    CHECK_EQ(0, result);
+  }
+}
+
+
+TEST(RunChangeBitToBool) {
+  ChangesLoweringTester<Object*> t(MachineType::Int32());
+  t.BuildAndLower(t.simplified()->ChangeBitToBool());
+
+  {
+    Object* result = t.Call(1);
+    Object* true_obj = t.heap()->true_value();
+    CHECK_EQ(true_obj, result);
+  }
+
+  {
+    Object* result = t.Call(0);
+    Object* false_obj = t.heap()->false_value();
+    CHECK_EQ(false_obj, result);
+  }
+}
+
+}  // namespace compiler
+}  // namespace internal
+}  // namespace v8

test/cctest/compiler/test-representation-change.cc

@@ -439,14 +439,13 @@ static void CheckTwoChanges(IrOpcode::Value expected2,
 
 
 TEST(SingleChanges) {
-  CheckChange(IrOpcode::kChangeTaggedToBit, MachineRepresentation::kTagged,
+  CheckChange(IrOpcode::kChangeBoolToBit, MachineRepresentation::kTagged,
               Type::None(), MachineRepresentation::kBit);
-  CheckChange(IrOpcode::kChangeBitToTagged, MachineRepresentation::kBit,
+  CheckChange(IrOpcode::kChangeBitToBool, MachineRepresentation::kBit,
               Type::None(), MachineRepresentation::kTagged);
 
-  CheckChange(IrOpcode::kChangeInt31ToTaggedSigned,
-              MachineRepresentation::kWord32, Type::Signed31(),
-              MachineRepresentation::kTagged);
+  CheckChange(IrOpcode::kChangeInt31ToTagged, MachineRepresentation::kWord32,
+              Type::Signed31(), MachineRepresentation::kTagged);
   CheckChange(IrOpcode::kChangeInt32ToTagged, MachineRepresentation::kWord32,
               Type::Signed32(), MachineRepresentation::kTagged);
   CheckChange(IrOpcode::kChangeUint32ToTagged, MachineRepresentation::kWord32,
@@ -454,7 +453,7 @@ TEST(SingleChanges) {
   CheckChange(IrOpcode::kChangeFloat64ToTagged, MachineRepresentation::kFloat64,
               Type::Number(), MachineRepresentation::kTagged);
   CheckTwoChanges(IrOpcode::kChangeFloat64ToInt32,
-                  IrOpcode::kChangeInt31ToTaggedSigned,
+                  IrOpcode::kChangeInt31ToTagged,
                   MachineRepresentation::kFloat64, Type::Signed31(),
                   MachineRepresentation::kTagged);
   CheckTwoChanges(IrOpcode::kChangeFloat64ToInt32,

test/cctest/compiler/test-simplified-lowering.cc

@@ -843,7 +843,7 @@ TEST(LowerBooleanNot_bit_tagged) {
   Node* use = t.Use(inv, MachineType::AnyTagged());
   t.Return(use);
   t.Lower();
-  CHECK_EQ(IrOpcode::kChangeBitToTagged, use->InputAt(0)->opcode());
+  CHECK_EQ(IrOpcode::kChangeBitToBool, use->InputAt(0)->opcode());
   Node* cmp = use->InputAt(0)->InputAt(0);
   CHECK_EQ(t.machine()->Word32Equal()->opcode(), cmp->opcode());
   CHECK(b == cmp->InputAt(0) || b == cmp->InputAt(1));
@@ -875,7 +875,7 @@ TEST(LowerBooleanNot_tagged_tagged) {
   Node* use = t.Use(inv, MachineType::AnyTagged());
   t.Return(use);
   t.Lower();
-  CHECK_EQ(IrOpcode::kChangeBitToTagged, use->InputAt(0)->opcode());
+  CHECK_EQ(IrOpcode::kChangeBitToBool, use->InputAt(0)->opcode());
   Node* cmp = use->InputAt(0)->InputAt(0);
   CHECK_EQ(t.machine()->WordEqual()->opcode(), cmp->opcode());
   CHECK(b == cmp->InputAt(0) || b == cmp->InputAt(1));
@@ -920,7 +920,7 @@ TEST(LowerBooleanToNumber_bit_tagged) {
   t.Return(use);
   t.Lower();
   CHECK_EQ(b, use->InputAt(0)->InputAt(0));
-  CHECK_EQ(IrOpcode::kChangeInt31ToTaggedSigned, use->InputAt(0)->opcode());
+  CHECK_EQ(IrOpcode::kChangeInt31ToTagged, use->InputAt(0)->opcode());
 }
 
 
@@ -933,7 +933,7 @@ TEST(LowerBooleanToNumber_tagged_tagged) {
   t.Return(use);
   t.Lower();
   CHECK_EQ(cnv, use->InputAt(0)->InputAt(0));
-  CHECK_EQ(IrOpcode::kChangeInt31ToTaggedSigned, use->InputAt(0)->opcode());
+  CHECK_EQ(IrOpcode::kChangeInt31ToTagged, use->InputAt(0)->opcode());
   CHECK_EQ(t.machine()->WordEqual()->opcode(), cnv->opcode());
   CHECK(b == cnv->InputAt(0) || b == cnv->InputAt(1));
   Node* c = t.jsgraph.TrueConstant();
@@ -1221,7 +1221,7 @@ TEST(InsertChangesAroundInt32Cmp) {
 
   for (size_t i = 0; i < arraysize(ops); i++) {
     CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToInt32,
-                            IrOpcode::kChangeBitToTagged);
+                            IrOpcode::kChangeBitToBool);
   }
 }
 
@@ -1234,7 +1234,7 @@ TEST(InsertChangesAroundUint32Cmp) {
 
   for (size_t i = 0; i < arraysize(ops); i++) {
     CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToUint32,
-                            IrOpcode::kChangeBitToTagged);
+                            IrOpcode::kChangeBitToBool);
   }
 }
 
@@ -1264,7 +1264,7 @@ TEST(InsertChangesAroundFloat64Cmp) {
 
   for (size_t i = 0; i < arraysize(ops); i++) {
     CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToFloat64,
-                            IrOpcode::kChangeBitToTagged);
+                            IrOpcode::kChangeBitToBool);
   }
 }
 

test/unittests/compiler/change-lowering-unittest.cc

@@ -105,6 +105,33 @@ class ChangeLoweringCommonTest
   MachineRepresentation WordRepresentation() const final { return GetParam(); }
 };
 
+
+TARGET_TEST_P(ChangeLoweringCommonTest, ChangeBitToBool) {
+  Node* value = Parameter(Type::Boolean());
+  Reduction r =
+      Reduce(graph()->NewNode(simplified()->ChangeBitToBool(), value));
+  ASSERT_TRUE(r.Changed());
+  EXPECT_THAT(r.replacement(), IsSelect(MachineRepresentation::kTagged, value,
+                                        IsTrueConstant(), IsFalseConstant()));
+}
+
+
+TARGET_TEST_P(ChangeLoweringCommonTest, ChangeBoolToBit) {
+  Node* value = Parameter(Type::Number());
+  Reduction r =
+      Reduce(graph()->NewNode(simplified()->ChangeBoolToBit(), value));
+  ASSERT_TRUE(r.Changed());
+  EXPECT_THAT(r.replacement(), IsWordEqual(value, IsTrueConstant()));
+}
+
+TARGET_TEST_P(ChangeLoweringCommonTest, ChangeInt31ToTagged) {
+  Node* value = Parameter(Type::SignedSmall());
+  Reduction r =
+      Reduce(graph()->NewNode(simplified()->ChangeInt31ToTagged(), value));
+  ASSERT_TRUE(r.Changed());
+  EXPECT_THAT(r.replacement(), IsChangeInt32ToSmi(value));
+}
+
 TARGET_TEST_P(ChangeLoweringCommonTest, StoreFieldSmi) {
   FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
                         Handle<Name>::null(), Type::Any(),

test/unittests/compiler/simplified-operator-reducer-unittest.cc

@@ -150,54 +150,60 @@ TEST_F(SimplifiedOperatorReducerTest, BooleanNotWithTrueConstant) {
 
 
 // -----------------------------------------------------------------------------
-// ChangeTaggedToBit
+// ChangeBoolToBit
 
-TEST_F(SimplifiedOperatorReducerTest, ChangeBitToTaggedWithChangeTaggedToBit) {
+
+TEST_F(SimplifiedOperatorReducerTest, ChangeBitToBoolWithChangeBoolToBit) {
   Node* param0 = Parameter(0);
   Reduction reduction = Reduce(graph()->NewNode(
-      simplified()->ChangeBitToTagged(),
-      graph()->NewNode(simplified()->ChangeTaggedToBit(), param0)));
+      simplified()->ChangeBitToBool(),
+      graph()->NewNode(simplified()->ChangeBoolToBit(), param0)));
   ASSERT_TRUE(reduction.Changed());
   EXPECT_EQ(param0, reduction.replacement());
 }
 
-TEST_F(SimplifiedOperatorReducerTest, ChangeBitToTaggedWithZeroConstant) {
+
+TEST_F(SimplifiedOperatorReducerTest, ChangeBitToBoolWithZeroConstant) {
   Reduction reduction = Reduce(
-      graph()->NewNode(simplified()->ChangeBitToTagged(), Int32Constant(0)));
+      graph()->NewNode(simplified()->ChangeBitToBool(), Int32Constant(0)));
   ASSERT_TRUE(reduction.Changed());
   EXPECT_THAT(reduction.replacement(), IsFalseConstant());
 }
 
-TEST_F(SimplifiedOperatorReducerTest, ChangeBitToTaggedWithOneConstant) {
+
+TEST_F(SimplifiedOperatorReducerTest, ChangeBitToBoolWithOneConstant) {
   Reduction reduction = Reduce(
-      graph()->NewNode(simplified()->ChangeBitToTagged(), Int32Constant(1)));
+      graph()->NewNode(simplified()->ChangeBitToBool(), Int32Constant(1)));
   ASSERT_TRUE(reduction.Changed());
   EXPECT_THAT(reduction.replacement(), IsTrueConstant());
 }
 
 
 // -----------------------------------------------------------------------------
-// ChangeTaggedToBit
+// ChangeBoolToBit
+
 
-TEST_F(SimplifiedOperatorReducerTest, ChangeTaggedToBitWithFalseConstant) {
+TEST_F(SimplifiedOperatorReducerTest, ChangeBoolToBitWithFalseConstant) {
   Reduction reduction = Reduce(
-      graph()->NewNode(simplified()->ChangeTaggedToBit(), FalseConstant()));
+      graph()->NewNode(simplified()->ChangeBoolToBit(), FalseConstant()));
   ASSERT_TRUE(reduction.Changed());
   EXPECT_THAT(reduction.replacement(), IsInt32Constant(0));
 }
 
-TEST_F(SimplifiedOperatorReducerTest, ChangeTaggedToBitWithTrueConstant) {
-  Reduction reduction = Reduce(
-      graph()->NewNode(simplified()->ChangeTaggedToBit(), TrueConstant()));
+
+TEST_F(SimplifiedOperatorReducerTest, ChangeBoolToBitWithTrueConstant) {
+  Reduction reduction =
+      Reduce(graph()->NewNode(simplified()->ChangeBoolToBit(), TrueConstant()));
   ASSERT_TRUE(reduction.Changed());
   EXPECT_THAT(reduction.replacement(), IsInt32Constant(1));
 }
 
-TEST_F(SimplifiedOperatorReducerTest, ChangeTaggedToBitWithChangeBitToTagged) {
+
+TEST_F(SimplifiedOperatorReducerTest, ChangeBoolToBitWithChangeBitToBool) {
   Node* param0 = Parameter(0);
   Reduction reduction = Reduce(graph()->NewNode(
-      simplified()->ChangeTaggedToBit(),
-      graph()->NewNode(simplified()->ChangeBitToTagged(), param0)));
+      simplified()->ChangeBoolToBit(),
+      graph()->NewNode(simplified()->ChangeBitToBool(), param0)));
   ASSERT_TRUE(reduction.Changed());
   EXPECT_EQ(param0, reduction.replacement());
 }

test/unittests/compiler/simplified-operator-unittest.cc

@@ -62,8 +62,8 @@ const PureOperator kPureOperators[] = {
     PURE(ChangeInt32ToTagged, Operator::kNoProperties, 1),
     PURE(ChangeUint32ToTagged, Operator::kNoProperties, 1),
     PURE(ChangeFloat64ToTagged, Operator::kNoProperties, 1),
-    PURE(ChangeTaggedToBit, Operator::kNoProperties, 1),
-    PURE(ChangeBitToTagged, Operator::kNoProperties, 1),
+    PURE(ChangeBoolToBit, Operator::kNoProperties, 1),
+    PURE(ChangeBitToBool, Operator::kNoProperties, 1),
     PURE(TruncateTaggedToWord32, Operator::kNoProperties, 1),
     PURE(ObjectIsNumber, Operator::kNoProperties, 1),
     PURE(ObjectIsReceiver, Operator::kNoProperties, 1),