[turbofan] Drop V8_TURBOFAN_BACKEND and V8_TURBOFAN_TARGET defines.

test/cctest/compiler/test-simplified-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/compiler/access-builder.h"
 #include "src/compiler/change-lowering.h"
 #include "src/compiler/control-builders.h"
 #include "src/compiler/graph-reducer.h"
@@ skipping 92 matching lines @@
   Node* loaded = t.LoadField(load, t.PointerConstant(&input));
   NodeProperties::SetBounds(loaded, Bounds(Type::Number()));
   Node* convert = t.NumberToInt32(loaded);
   FieldAccess store = {kUntaggedBase, 0, Handle<Name>(), Type::Signed32(),
                        kMachInt32};
   t.StoreField(store, t.PointerConstant(&result), convert);
   t.Return(t.jsgraph.TrueConstant());
   t.LowerAllNodes();
   t.GenerateCode();
 
-  if (Pipeline::SupportedTarget()) {
     FOR_FLOAT64_INPUTS(i) {
       input = *i;
       int32_t expected = DoubleToInt32(*i);
       t.Call();
       CHECK_EQ(expected, result);
     }
-  }
 }
 
 
 // TODO(titzer): test tagged representation for input to NumberToUint32.
 TEST(RunNumberToUint32_float64) {
   // TODO(titzer): explicit load/stores here are only because of representations
   double input;
   uint32_t result;
   SimplifiedLoweringTester<Object*> t;
   FieldAccess load = {kUntaggedBase, 0, Handle<Name>(), Type::Number(),
                       kMachFloat64};
   Node* loaded = t.LoadField(load, t.PointerConstant(&input));
   NodeProperties::SetBounds(loaded, Bounds(Type::Number()));
   Node* convert = t.NumberToUint32(loaded);
   FieldAccess store = {kUntaggedBase, 0, Handle<Name>(), Type::Unsigned32(),
                        kMachUint32};
   t.StoreField(store, t.PointerConstant(&result), convert);
   t.Return(t.jsgraph.TrueConstant());
   t.LowerAllNodes();
   t.GenerateCode();
 
-  if (Pipeline::SupportedTarget()) {
     FOR_FLOAT64_INPUTS(i) {
       input = *i;
       uint32_t expected = DoubleToUint32(*i);
       t.Call();
       CHECK_EQ(static_cast<int32_t>(expected), static_cast<int32_t>(result));
     }
   }
-}
 
 
 // Create a simple JSObject with a unique map.
 static Handle<JSObject> TestObject() {
   static int index = 0;
   char buffer[50];
   v8::base::OS::SNPrintF(buffer, 50, "({'a_%d':1})", index++);
   return Handle<JSObject>::cast(v8::Utils::OpenHandle(*CompileRun(buffer)));
 }
 
 
 TEST(RunLoadMap) {
   SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
   FieldAccess access = AccessBuilder::ForMap();
   Node* load = t.LoadField(access, t.Parameter(0));
   t.Return(load);
 
   t.LowerAllNodes();
   t.GenerateCode();
 
-  if (Pipeline::SupportedTarget()) {
-    Handle<JSObject> src = TestObject();
-    Handle<Map> src_map(src->map());
-    Object* result = t.Call(*src);  // TODO(titzer): raw pointers in call
-    CHECK_EQ(*src_map, result);
-  }
+  Handle<JSObject> src = TestObject();
+  Handle<Map> src_map(src->map());
+  Object* result = t.Call(*src);  // TODO(titzer): raw pointers in call
+  CHECK_EQ(*src_map, result);
 }
 
 
 TEST(RunStoreMap) {
   SimplifiedLoweringTester<int32_t> t(kMachAnyTagged, kMachAnyTagged);
   FieldAccess access = AccessBuilder::ForMap();
   t.StoreField(access, t.Parameter(1), t.Parameter(0));
   t.Return(t.jsgraph.TrueConstant());
 
   t.LowerAllNodes();
   t.GenerateCode();
 
-  if (Pipeline::SupportedTarget()) {
     Handle<JSObject> src = TestObject();
     Handle<Map> src_map(src->map());
     Handle<JSObject> dst = TestObject();
     CHECK(src->map() != dst->map());
     t.Call(*src_map, *dst);  // TODO(titzer): raw pointers in call
     CHECK(*src_map == dst->map());
   }
-}
 
 
 TEST(RunLoadProperties) {
   SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
   FieldAccess access = AccessBuilder::ForJSObjectProperties();
   Node* load = t.LoadField(access, t.Parameter(0));
   t.Return(load);
 
   t.LowerAllNodes();
   t.GenerateCode();
 
-  if (Pipeline::SupportedTarget()) {
     Handle<JSObject> src = TestObject();
     Handle<FixedArray> src_props(src->properties());
     Object* result = t.Call(*src);  // TODO(titzer): raw pointers in call
     CHECK_EQ(*src_props, result);
-  }
 }
 
 
 TEST(RunLoadStoreMap) {
   SimplifiedLoweringTester<Object*> t(kMachAnyTagged, kMachAnyTagged);
   FieldAccess access = AccessBuilder::ForMap();
   Node* load = t.LoadField(access, t.Parameter(0));
   t.StoreField(access, t.Parameter(1), load);
   t.Return(load);
 
   t.LowerAllNodes();
   t.GenerateCode();
 
-  if (Pipeline::SupportedTarget()) {
     Handle<JSObject> src = TestObject();
     Handle<Map> src_map(src->map());
     Handle<JSObject> dst = TestObject();
     CHECK(src->map() != dst->map());
     Object* result = t.Call(*src, *dst);  // TODO(titzer): raw pointers in call
     CHECK(result->IsMap());
     CHECK_EQ(*src_map, result);
     CHECK(*src_map == dst->map());
-  }
 }
 
 
 TEST(RunLoadStoreFixedArrayIndex) {
   SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
   ElementAccess access = AccessBuilder::ForFixedArrayElement();
   Node* load = t.LoadElement(access, t.Parameter(0), t.Int32Constant(0));
   t.StoreElement(access, t.Parameter(0), t.Int32Constant(1), load);
   t.Return(load);
 
   t.LowerAllNodes();
   t.GenerateCode();
 
-  if (Pipeline::SupportedTarget()) {
     Handle<FixedArray> array = t.factory()->NewFixedArray(2);
     Handle<JSObject> src = TestObject();
     Handle<JSObject> dst = TestObject();
     array->set(0, *src);
     array->set(1, *dst);
     Object* result = t.Call(*array);
     CHECK_EQ(*src, result);
     CHECK_EQ(*src, array->get(0));
     CHECK_EQ(*src, array->get(1));
-  }
 }
 
 
 TEST(RunLoadStoreArrayBuffer) {
   SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
   const int index = 12;
   const int array_length = 2 * index;
   ElementAccess buffer_access =
       AccessBuilder::ForTypedArrayElement(kExternalInt8Array, true);
   Node* backing_store = t.LoadField(
       AccessBuilder::ForJSArrayBufferBackingStore(), t.Parameter(0));
   Node* load =
       t.LoadElement(buffer_access, backing_store, t.Int32Constant(index));
   t.StoreElement(buffer_access, backing_store, t.Int32Constant(index + 1),
                  load);
   t.Return(t.jsgraph.TrueConstant());
 
   t.LowerAllNodes();
   t.GenerateCode();
 
-  if (Pipeline::SupportedTarget()) {
     Handle<JSArrayBuffer> array = t.factory()->NewJSArrayBuffer();
     Runtime::SetupArrayBufferAllocatingData(t.isolate(), array, array_length);
     uint8_t* data = reinterpret_cast<uint8_t*>(array->backing_store());
     for (int i = 0; i < array_length; i++) {
       data[i] = i;
     }
 
     // TODO(titzer): raw pointers in call
     Object* result = t.Call(*array);
     CHECK_EQ(t.isolate()->heap()->true_value(), result);
     for (int i = 0; i < array_length; i++) {
       uint8_t expected = i;
       if (i == (index + 1)) expected = index;
       CHECK_EQ(data[i], expected);
     }
   }
-}
 
 
 TEST(RunLoadFieldFromUntaggedBase) {
   Smi* smis[] = {Smi::FromInt(1), Smi::FromInt(2), Smi::FromInt(3)};
 
   for (size_t i = 0; i < arraysize(smis); i++) {
     int offset = static_cast<int>(i * sizeof(Smi*));
     FieldAccess access = {kUntaggedBase, offset, Handle<Name>(),
                           Type::Integral32(), kMachAnyTagged};
 
     SimplifiedLoweringTester<Object*> t;
     Node* load = t.LoadField(access, t.PointerConstant(smis));
     t.Return(load);
     t.LowerAllNodes();
 
-    if (!Pipeline::SupportedTarget()) continue;
-
     for (int j = -5; j <= 5; j++) {
       Smi* expected = Smi::FromInt(j);
       smis[i] = expected;
       CHECK_EQ(expected, t.Call());
     }
   }
 }
 
 
 TEST(RunStoreFieldToUntaggedBase) {
   Smi* smis[] = {Smi::FromInt(1), Smi::FromInt(2), Smi::FromInt(3)};
 
   for (size_t i = 0; i < arraysize(smis); i++) {
     int offset = static_cast<int>(i * sizeof(Smi*));
     FieldAccess access = {kUntaggedBase, offset, Handle<Name>(),
                           Type::Integral32(), kMachAnyTagged};
 
     SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
     Node* p0 = t.Parameter(0);
     t.StoreField(access, t.PointerConstant(smis), p0);
     t.Return(p0);
     t.LowerAllNodes();
 
-    if (!Pipeline::SupportedTarget()) continue;
-
     for (int j = -5; j <= 5; j++) {
       Smi* expected = Smi::FromInt(j);
       smis[i] = Smi::FromInt(-100);
       CHECK_EQ(expected, t.Call(expected));
       CHECK_EQ(expected, smis[i]);
     }
   }
 }
 
 
 TEST(RunLoadElementFromUntaggedBase) {
   Smi* smis[] = {Smi::FromInt(1), Smi::FromInt(2), Smi::FromInt(3),
                  Smi::FromInt(4), Smi::FromInt(5)};
 
   for (size_t i = 0; i < arraysize(smis); i++) {    // for header sizes
     for (size_t j = 0; (i + j) < arraysize(smis); j++) {  // for element index
       int offset = static_cast<int>(i * sizeof(Smi*));
       ElementAccess access = {kUntaggedBase, offset, Type::Integral32(),
                               kMachAnyTagged};
 
       SimplifiedLoweringTester<Object*> t;
       Node* load = t.LoadElement(access, t.PointerConstant(smis),
                                  t.Int32Constant(static_cast<int>(j)));
       t.Return(load);
       t.LowerAllNodes();
 
-      if (!Pipeline::SupportedTarget()) continue;
-
       for (int k = -5; k <= 5; k++) {
         Smi* expected = Smi::FromInt(k);
         smis[i + j] = expected;
         CHECK_EQ(expected, t.Call());
       }
     }
   }
 }
 
 
 TEST(RunStoreElementFromUntaggedBase) {
   Smi* smis[] = {Smi::FromInt(1), Smi::FromInt(2), Smi::FromInt(3),
                  Smi::FromInt(4), Smi::FromInt(5)};
 
   for (size_t i = 0; i < arraysize(smis); i++) {    // for header sizes
     for (size_t j = 0; (i + j) < arraysize(smis); j++) {  // for element index
       int offset = static_cast<int>(i * sizeof(Smi*));
       ElementAccess access = {kUntaggedBase, offset, Type::Integral32(),
                               kMachAnyTagged};
 
       SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
       Node* p0 = t.Parameter(0);
       t.StoreElement(access, t.PointerConstant(smis),
                      t.Int32Constant(static_cast<int>(j)), p0);
       t.Return(p0);
       t.LowerAllNodes();
 
-      if (!Pipeline::SupportedTarget()) continue;
-
       for (int k = -5; k <= 5; k++) {
         Smi* expected = Smi::FromInt(k);
         smis[i + j] = Smi::FromInt(-100);
         CHECK_EQ(expected, t.Call(expected));
         CHECK_EQ(expected, smis[i + j]);
       }
 
       // TODO(titzer): assert the contents of the array.
     }
   }
@@ skipping 46 matching lines @@
     ElementAccess access = GetElementAccess();
 
     SimplifiedLoweringTester<Object*> t;
     Node* ptr = GetBaseNode(&t);
     Node* load = t.LoadElement(access, ptr, t.Int32Constant(from_index));
     t.StoreElement(access, ptr, t.Int32Constant(to_index), load);
     t.Return(t.jsgraph.TrueConstant());
     t.LowerAllNodes();
     t.GenerateCode();
 
-    if (Pipeline::SupportedTarget()) {
       Object* result = t.Call();
       CHECK_EQ(t.isolate()->heap()->true_value(), result);
-    }
   }
 
   // Create and run code that copies the field in either {untagged_array}
   // or {tagged_array} at index {from_index} to index {to_index}.
   void RunCopyField(int from_index, int to_index) {
     BoundsCheck(from_index);
     BoundsCheck(to_index);
     FieldAccess from_access = GetFieldAccess(from_index);
     FieldAccess to_access = GetFieldAccess(to_index);
 
     SimplifiedLoweringTester<Object*> t;
     Node* ptr = GetBaseNode(&t);
     Node* load = t.LoadField(from_access, ptr);
     t.StoreField(to_access, ptr, load);
     t.Return(t.jsgraph.TrueConstant());
     t.LowerAllNodes();
     t.GenerateCode();
 
-    if (Pipeline::SupportedTarget()) {
       Object* result = t.Call();
       CHECK_EQ(t.isolate()->heap()->true_value(), result);
-    }
   }
 
   // Create and run code that copies the elements from {this} to {that}.
   void RunCopyElements(AccessTester<E>* that) {
 // TODO(titzer): Rewrite this test without StructuredGraphBuilder support.
 #if 0
     SimplifiedLoweringTester<Object*> t;
 
     Node* one = t.Int32Constant(1);
     Node* index = t.Int32Constant(0);
@@ skipping 17 matching lines @@
       t.environment()->Push(index);
       // continue
       loop.EndBody();
       loop.EndLoop();
     }
     index = t.environment()->Pop();
     t.Return(t.jsgraph.TrueConstant());
     t.LowerAllNodes();
     t.GenerateCode();
 
-    if (Pipeline::SupportedTarget()) {
       Object* result = t.Call();
       CHECK_EQ(t.isolate()->heap()->true_value(), result);
-    }
 #endif
   }
 
   E GetElement(int index) {
     BoundsCheck(index);
     if (tagged) {
       return GetTaggedElement(index);
     } else {
       return untagged_array[index];
     }
@@ skipping 47 matching lines @@
   for (int taggedness = 0; taggedness < 2; taggedness++) {
     AccessTester<E> a(taggedness == 1, rep, original_elements, num);
     for (int field = 0; field < 2; field++) {
       for (int i = 0; i < num_elements - 1; i++) {
         a.Reinitialize();
         if (field == 0) {
           a.RunCopyField(i, i + 1);  // Test field read/write.
         } else {
           a.RunCopyElement(i, i + 1);  // Test element read/write.
         }
-        if (Pipeline::SupportedTarget()) {  // verify.
           for (int j = 0; j < num_elements; j++) {
             E expect =
                 j == (i + 1) ? original_elements[i] : original_elements[j];
             CHECK_EQ(expect, a.GetElement(j));
           }
-        }
       }
     }
   }
   // Test array copy.
   for (int tf = 0; tf < 2; tf++) {
     for (int tt = 0; tt < 2; tt++) {
       AccessTester<E> a(tf == 1, rep, original_elements, num);
       AccessTester<E> b(tt == 1, rep, original_elements, num);
       a.RunCopyElements(&b);
-      if (Pipeline::SupportedTarget()) {  // verify.
         for (int i = 0; i < num_elements; i++) {
           CHECK_EQ(a.GetElement(i), b.GetElement(i));
-        }
       }
     }
   }
 }
 
 
 TEST(RunAccessTests_uint8) {
   uint8_t data[] = {0x07, 0x16, 0x25, 0x34, 0x43, 0x99,
                     0xab, 0x78, 0x89, 0x19, 0x2b, 0x38};
   RunAccessTest<uint8_t>(kMachInt8, data, arraysize(data));
@@ skipping 32 matching lines @@
 }
 
 
 TEST(RunAccessTests_Smi) {
   Smi* data[] = {Smi::FromInt(-1),    Smi::FromInt(-9),
                  Smi::FromInt(0),     Smi::FromInt(666),
                  Smi::FromInt(77777), Smi::FromInt(Smi::kMaxValue)};
   RunAccessTest<Smi*>(kMachAnyTagged, data, arraysize(data));
 }
 
-#if V8_TURBOFAN_TARGET
+
 TEST(RunAllocate) {
   PretenureFlag flag[] = {NOT_TENURED, TENURED};
 
   for (size_t i = 0; i < arraysize(flag); i++) {
     SimplifiedLoweringTester<HeapObject*> t;
     FieldAccess access = AccessBuilder::ForMap();
     Node* size = t.jsgraph.Constant(HeapNumber::kSize);
     Node* alloc = t.NewNode(t.simplified()->Allocate(flag[i]), size);
     Node* map = t.jsgraph.Constant(t.factory()->heap_number_map());
     t.StoreField(access, alloc, map);
     t.Return(alloc);
 
     t.LowerAllNodes();
     t.GenerateCode();
 
-    if (Pipeline::SupportedTarget()) {
       HeapObject* result = t.CallWithPotentialGC<HeapObject>();
       CHECK(t.heap()->new_space()->Contains(result) || flag[i] == TENURED);
       CHECK(t.heap()->old_space()->Contains(result) || flag[i] == NOT_TENURED);
       CHECK(result->IsHeapNumber());
-    }
   }
 }
-#endif
+
 
 // Fills in most of the nodes of the graph in order to make tests shorter.
 class TestingGraph : public HandleAndZoneScope, public GraphAndBuilders {
  public:
   Typer typer;
   JSOperatorBuilder javascript;
   JSGraph jsgraph;
   Node* p0;
   Node* p1;
   Node* p2;
@@ skipping 551 matching lines @@
 
 TEST(LowerReferenceEqual_to_wordeq) {
   TestingGraph t(Type::Any(), Type::Any());
   IrOpcode::Value opcode =
       static_cast<IrOpcode::Value>(t.machine()->WordEqual()->opcode());
   t.CheckLoweringBinop(opcode, t.simplified()->ReferenceEqual(Type::Any()));
 }
 
 
 TEST(LowerStringOps_to_call_and_compare) {
-  if (Pipeline::SupportedTarget()) {
     // These tests need linkage for the calls.
     TestingGraph t(Type::String(), Type::String());
     IrOpcode::Value compare_eq =
         static_cast<IrOpcode::Value>(t.machine()->WordEqual()->opcode());
     IrOpcode::Value compare_lt =
         static_cast<IrOpcode::Value>(t.machine()->IntLessThan()->opcode());
     IrOpcode::Value compare_le = static_cast<IrOpcode::Value>(
         t.machine()->IntLessThanOrEqual()->opcode());
     t.CheckLoweringBinop(compare_eq, t.simplified()->StringEqual());
     t.CheckLoweringBinop(compare_lt, t.simplified()->StringLessThan());
     t.CheckLoweringBinop(compare_le, t.simplified()->StringLessThanOrEqual());
   }
-}
 
 
 void CheckChangeInsertion(IrOpcode::Value expected, MachineType from,
                           MachineType to) {
   TestingGraph t(Type::Any());
   Node* in = t.ExampleWithOutput(from);
   Node* use = t.Use(in, to);
   t.Return(use);
   t.Lower();
   CHECK_EQ(expected, use->InputAt(0)->opcode());
@@ skipping 410 matching lines @@
 }
 
 
 TEST(RunNumberDivide_minus_1_TruncatingToInt32) {
   SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
   Node* num = t.NumberToInt32(t.Parameter(0));
   Node* div = t.NumberDivide(num, t.jsgraph.Constant(-1));
   Node* trunc = t.NumberToInt32(div);
   t.Return(trunc);
 
-  if (Pipeline::SupportedTarget()) {
     t.LowerAllNodesAndLowerChanges();
     t.GenerateCode();
 
     FOR_INT32_INPUTS(i) {
       int32_t x = 0 - *i;
       t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
     }
-  }
 }
 
 
 TEST(NumberMultiply_TruncatingToInt32) {
   int32_t constants[] = {-100, -10, -1, 0, 1, 100, 1000};
 
   for (size_t i = 0; i < arraysize(constants); i++) {
     TestingGraph t(Type::Signed32());
     Node* k = t.jsgraph.Constant(constants[i]);
     Node* mul = t.graph()->NewNode(t.simplified()->NumberMultiply(), t.p0, k);
@@ skipping 10 matching lines @@
   int32_t constants[] = {-100, -10, -1, 0, 1, 100, 1000, 3000999};
 
   for (size_t i = 0; i < arraysize(constants); i++) {
     double k = static_cast<double>(constants[i]);
     SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
     Node* num = t.NumberToInt32(t.Parameter(0));
     Node* mul = t.NumberMultiply(num, t.jsgraph.Constant(k));
     Node* trunc = t.NumberToInt32(mul);
     t.Return(trunc);
 
-    if (Pipeline::SupportedTarget()) {
       t.LowerAllNodesAndLowerChanges();
       t.GenerateCode();
 
       FOR_INT32_INPUTS(i) {
         int32_t x = DoubleToInt32(static_cast<double>(*i) * k);
         t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
       }
     }
-  }
 }
 
 
 TEST(RunNumberMultiply_TruncatingToUint32) {
   uint32_t constants[] = {0, 1, 2, 3, 4, 100, 1000, 1024, 2048, 3000999};
 
   for (size_t i = 0; i < arraysize(constants); i++) {
     double k = static_cast<double>(constants[i]);
     SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
     Node* num = t.NumberToUint32(t.Parameter(0));
     Node* mul = t.NumberMultiply(num, t.jsgraph.Constant(k));
     Node* trunc = t.NumberToUint32(mul);
     t.Return(trunc);
 
-    if (Pipeline::SupportedTarget()) {
       t.LowerAllNodesAndLowerChanges();
       t.GenerateCode();
 
       FOR_UINT32_INPUTS(i) {
         uint32_t x = DoubleToUint32(static_cast<double>(*i) * k);
         t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
-      }
     }
   }
 }
 
 
 TEST(RunNumberDivide_2_TruncatingToUint32) {
   SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
   Node* num = t.NumberToUint32(t.Parameter(0));
   Node* div = t.NumberDivide(num, t.jsgraph.Constant(2));
   Node* trunc = t.NumberToUint32(div);
   t.Return(trunc);
 
-  if (Pipeline::SupportedTarget()) {
     t.LowerAllNodesAndLowerChanges();
     t.GenerateCode();
 
     FOR_UINT32_INPUTS(i) {
       uint32_t x = DoubleToUint32(static_cast<double>(*i / 2.0));
       t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
     }
-  }
 }
 
 
 TEST(NumberMultiply_ConstantOutOfRange) {
   TestingGraph t(Type::Signed32());
   Node* k = t.jsgraph.Constant(1000000023);
   Node* mul = t.graph()->NewNode(t.simplified()->NumberMultiply(), t.p0, k);
   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), mul);
   t.Return(trunc);
   t.Lower();
@@ skipping 33 matching lines @@
   int32_t constants[] = {-100, -10, -1, 1, 2, 100, 1000, 1024, 2048};
 
   for (size_t i = 0; i < arraysize(constants); i++) {
     int32_t k = constants[i];
     SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
     Node* num = t.NumberToInt32(t.Parameter(0));
     Node* div = t.NumberDivide(num, t.jsgraph.Constant(k));
     Node* trunc = t.NumberToInt32(div);
     t.Return(trunc);
 
-    if (Pipeline::SupportedTarget()) {
       t.LowerAllNodesAndLowerChanges();
       t.GenerateCode();
 
       FOR_INT32_INPUTS(i) {
         if (*i == INT_MAX) continue;  // exclude max int.
         int32_t x = DoubleToInt32(static_cast<double>(*i) / k);
         t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
-      }
     }
   }
 }
 
 
 TEST(NumberDivide_TruncatingToUint32) {
   double constants[] = {1, 3, 100, 1000, 100998348};
 
   for (size_t i = 0; i < arraysize(constants); i++) {
     TestingGraph t(Type::Unsigned32());
@@ skipping 12 matching lines @@
   uint32_t constants[] = {100, 10, 1, 1, 2, 4, 1000, 1024, 2048};
 
   for (size_t i = 0; i < arraysize(constants); i++) {
     uint32_t k = constants[i];
     SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
     Node* num = t.NumberToUint32(t.Parameter(0));
     Node* div = t.NumberDivide(num, t.jsgraph.Constant(static_cast<double>(k)));
     Node* trunc = t.NumberToUint32(div);
     t.Return(trunc);
 
-    if (Pipeline::SupportedTarget()) {
       t.LowerAllNodesAndLowerChanges();
       t.GenerateCode();
 
       FOR_UINT32_INPUTS(i) {
         uint32_t x = *i / k;
         t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
-      }
     }
   }
 }
 
 
 TEST(NumberDivide_BadConstants) {
   {
     TestingGraph t(Type::Signed32());
     Node* k = t.jsgraph.Constant(-1);
     Node* div = t.graph()->NewNode(t.simplified()->NumberDivide(), t.p0, k);
@@ skipping 50 matching lines @@
   int32_t constants[] = {-100, -10, -1, 1, 2, 100, 1000, 1024, 2048};
 
   for (size_t i = 0; i < arraysize(constants); i++) {
     int32_t k = constants[i];
     SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
     Node* num = t.NumberToInt32(t.Parameter(0));
     Node* mod = t.NumberModulus(num, t.jsgraph.Constant(k));
     Node* trunc = t.NumberToInt32(mod);
     t.Return(trunc);
 
-    if (Pipeline::SupportedTarget()) {
       t.LowerAllNodesAndLowerChanges();
       t.GenerateCode();
 
       FOR_INT32_INPUTS(i) {
         if (*i == INT_MAX) continue;  // exclude max int.
         int32_t x = DoubleToInt32(std::fmod(static_cast<double>(*i), k));
         t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
-      }
     }
   }
 }
 
 
 TEST(NumberModulus_TruncatingToUint32) {
   double constants[] = {1, 3, 100, 1000, 100998348};
 
   for (size_t i = 0; i < arraysize(constants); i++) {
     TestingGraph t(Type::Unsigned32());
@@ skipping 13 matching lines @@
 
   for (size_t i = 0; i < arraysize(constants); i++) {
     uint32_t k = constants[i];
     SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
     Node* num = t.NumberToUint32(t.Parameter(0));
     Node* mod =
         t.NumberModulus(num, t.jsgraph.Constant(static_cast<double>(k)));
     Node* trunc = t.NumberToUint32(mod);
     t.Return(trunc);
 
-    if (Pipeline::SupportedTarget()) {
       t.LowerAllNodesAndLowerChanges();
       t.GenerateCode();
 
       FOR_UINT32_INPUTS(i) {
         uint32_t x = *i % k;
         t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
-      }
     }
   }
 }
 
 
 TEST(NumberModulus_Int32) {
   int32_t constants[] = {-100, -10, 1, 4, 100, 1000};
 
   for (size_t i = 0; i < arraysize(constants); i++) {
     TestingGraph t(Type::Signed32());
@@ skipping 61 matching lines @@
     Bounds phi_bounds = Bounds::Either(Bounds(d.arg1), Bounds(d.arg2), z);
     NodeProperties::SetBounds(phi, phi_bounds);
 
     Node* use = t.Use(phi, d.use);
     t.Return(use);
     t.Lower();
 
     CHECK_EQ(d.expected, OpParameter<MachineType>(phi));
   }
 }