TF: simplified-lowering tests accidentally ran on unsupported platforms.

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/control-builders.h"
 #include "src/compiler/generic-node-inl.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/pipeline.h"
@@ skipping 312 matching lines @@
   for (size_t i = 0; i < ARRAY_SIZE(smis); i++) {
     FieldAccess access = {kUntaggedBase,     // untagged base
                           i * sizeof(Smi*),  // offset
                           Handle<Name>(), Type::Integral32(), kMachineTagged};
 
     SimplifiedGraphBuilderTester<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 < ARRAY_SIZE(smis); i++) {
     FieldAccess access = {kUntaggedBase,     // untagged base
                           i * sizeof(Smi*),  // offset
                           Handle<Name>(), Type::Integral32(), kMachineTagged};
 
     SimplifiedGraphBuilderTester<Object*> t(kMachineTagged);
     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 < ARRAY_SIZE(smis); i++) {    // for header sizes
     for (size_t j = i; j < ARRAY_SIZE(smis); j++) {  // for element index
       ElementAccess access = {kUntaggedBase,         // untagged base
                               i * sizeof(Smi*),      // header size
                               Type::Integral32(), kMachineTagged};
 
       SimplifiedGraphBuilderTester<Object*> t;
       Node* load =
           t.LoadElement(access, t.PointerConstant(smis), t.Int32Constant(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 < ARRAY_SIZE(smis); i++) {    // for header sizes
     for (size_t j = i; j < ARRAY_SIZE(smis); j++) {  // for element index
       ElementAccess access = {kUntaggedBase,         // untagged base
                               i * sizeof(Smi*),      // header size
                               Type::Integral32(), kMachineTagged};
 
       SimplifiedGraphBuilderTester<Object*> t(kMachineTagged);
       Node* p0 = t.Parameter(0);
       t.StoreElement(access, t.PointerConstant(smis), t.Int32Constant(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]);
       }
     }
   }
 }