Fixed GCMole issues after r26667.

test/cctest/test-migrations.cc

 // Copyright 2015 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 <stdlib.h>
 #include <utility>
 
 #include "src/v8.h"
 
 #include "src/code-stubs.h"
@@ skipping 45 matching lines @@
   SNPrintF(buffer, "%s%d", str, suffix);
   return MakeString(buffer.start());
 }
 
 
 static Handle<AccessorPair> CreateAccessorPair(bool with_getter,
                                                bool with_setter) {
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   Handle<AccessorPair> pair = factory->NewAccessorPair();
+  Handle<String> empty_string = factory->empty_string();
   if (with_getter) {
-    pair->set_getter(*factory->NewFunction(factory->empty_string()));
+    Handle<JSFunction> func = factory->NewFunction(empty_string);
+    pair->set_getter(*func);
   }
   if (with_setter) {
-    pair->set_setter(*factory->NewFunction(factory->empty_string()));
+    Handle<JSFunction> func = factory->NewFunction(empty_string);
+    pair->set_setter(*func);
   }
   return pair;
 }
 
 
 static bool EqualDetails(DescriptorArray* descriptors, int descriptor,
                          PropertyType type, PropertyAttributes attributes,
                          Representation representation, int field_index = -1) {
   PropertyDetails details = descriptors->GetDetails(descriptor);
   if (details.type() != type) return false;
@@ skipping 355 matching lines @@
   CHECK(!map->is_deprecated());
   CHECK(map->is_stable());
   CHECK(expectations.Check(*map));
 
   expectations.SetDataField(0, NONE, Representation::None(), none_type);
 
   CHECK(!new_map->is_deprecated());
   CHECK(new_map->is_stable());
   CHECK(expectations.Check(*new_map));
 
-  CHECK_EQ(*new_map, *Map::ReconfigureProperty(map, 0, kData, NONE,
-                                               Representation::None(),
-                                               none_type, FORCE_FIELD));
+  Handle<Map> new_map2 = Map::ReconfigureProperty(
+      map, 0, kData, NONE, Representation::None(), none_type, FORCE_FIELD);
+  CHECK_EQ(*new_map, *new_map2);
 
   Handle<Object> value(Smi::FromInt(0), isolate);
   Handle<Map> prepared_map = Map::PrepareForDataProperty(new_map, 0, value);
   // None to Smi generalization is trivial, map does not change.
   CHECK_EQ(*new_map, *prepared_map);
 
   expectations.SetDataField(0, NONE, Representation::Smi(), any_type);
   CHECK(prepared_map->is_stable());
   CHECK(expectations.Check(*prepared_map));
 
@@ skipping 105 matching lines @@
     CHECK(!new_map->is_dictionary_map());
     CHECK(expectations.Check(*new_map));
   }
 
   Handle<Map> active_map = maps[kPropCount - 1];
   CHECK(!active_map->is_deprecated());
 
   // Update all deprecated maps and check that they are now the same.
   CHECK_EQ(*active_map, *Map::Update(map));
   for (int i = 0; i < kPropCount; i++) {
-    CHECK_EQ(*active_map, *Map::Update(maps[i]));
+    Handle<Map> updated_map = Map::Update(maps[i]);
+    CHECK_EQ(*active_map, *updated_map);
   }
 }
 
 
 static void TestGeneralizeRepresentationTrivial(
     Representation from_representation, Handle<HeapType> from_type,
     Representation to_representation, Handle<HeapType> to_type,
     Representation expected_representation, Handle<HeapType> expected_type,
     bool expected_field_type_dependency = true) {
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 32 matching lines @@
              info.HasAbortedDueToDependencyChange());
 
     info.RollbackDependencies();  // Properly cleanup compilation info.
 
     CHECK_EQ(*map, *new_map);
     CHECK(!new_map->is_deprecated());
     CHECK(!new_map->is_dictionary_map());
     CHECK(expectations.Check(*new_map));
   }
 
-  CHECK_EQ(*map, *Map::Update(map));
+  Handle<Map> updated_map = Map::Update(map);
+  CHECK_EQ(*map, *updated_map);
 }
 
 
 TEST(GeneralizeRepresentationSmiToDouble) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<HeapType> any_type = HeapType::Any(isolate);
 
   TestGeneralizeRepresentation(Representation::Smi(), any_type,
@@ skipping 187 matching lines @@
     CHECK(!new_map->is_dictionary_map());
     CHECK(expectations.Check(*new_map));
   }
 
   Handle<Map> active_map = maps[kPropCount - 1];
   CHECK(!active_map->is_deprecated());
 
   // Update all deprecated maps and check that they are now the same.
   CHECK_EQ(*active_map, *Map::Update(map));
   for (int i = 0; i < kPropCount; i++) {
-    CHECK_EQ(*active_map, *Map::Update(maps[i]));
+    Handle<Map> updated_map = Map::Update(maps[i]);
+    CHECK_EQ(*active_map, *updated_map);
   }
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // A set of tests for attribute reconfiguration case.
 //
 
 // This test ensures that representation/field type generalization is correctly
 // propagated from one branch of transition tree (|map2|) to another (|map|).
@@ skipping 68 matching lines @@
   CHECK(map->is_deprecated());
   CHECK(!info.HasAbortedDueToDependencyChange());
   info.RollbackDependencies();  // Properly cleanup compilation info.
   CHECK_NE(*map, *new_map);
 
   CHECK(!new_map->is_deprecated());
   CHECK(!new_map->is_dictionary_map());
   CHECK(expectations.Check(*new_map));
 
   // Update deprecated |map|, it should become |new_map|.
-  CHECK_EQ(*new_map, *Map::Update(map));
+  Handle<Map> updated_map = Map::Update(map);
+  CHECK_EQ(*new_map, *updated_map);
 }
 
 
 // This test ensures that trivial representation/field type generalization
 // (from HeapObject to HeapObject) is correctly propagated from one branch of
 // transition tree (|map2|) to another (|map|).
 //
 //             + - p2B - p3 - p4: |map2|
 //             |
 //  {} - p0 - p1 - p2A - p3 - p4: |map|
@@ skipping 68 matching lines @@
   CHECK(!map->is_deprecated());
   CHECK_EQ(*map, *new_map);
   CHECK_EQ(expected_field_type_dependency,
            info.HasAbortedDueToDependencyChange());
   info.RollbackDependencies();  // Properly cleanup compilation info.
 
   CHECK(!new_map->is_deprecated());
   CHECK(!new_map->is_dictionary_map());
   CHECK(expectations.Check(*new_map));
 
-  CHECK_EQ(*new_map, *Map::Update(map));
+  Handle<Map> updated_map = Map::Update(map);
+  CHECK_EQ(*new_map, *updated_map);
 }
 
 
 TEST(ReconfigureDataFieldAttribute_GeneralizeRepresentationSmiToDouble) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<HeapType> any_type = HeapType::Any(isolate);
 
   TestReconfigureDataFieldAttribute_GeneralizeRepresentation(
@@ skipping 84 matching lines @@
   void Check(Handle<Map> map, Handle<Map> new_map,
              const Expectations& expectations) {
     CHECK(map->is_deprecated());
     CHECK_NE(*map, *new_map);
 
     CHECK(!new_map->is_deprecated());
     CHECK(!new_map->is_dictionary_map());
     CHECK(expectations.Check(*new_map));
 
     // Update deprecated |map|, it should become |new_map|.
-    CHECK_EQ(*new_map, *Map::Update(map));
+    Handle<Map> updated_map = Map::Update(map);
+    CHECK_EQ(*new_map, *updated_map);
   }
 };
 
 
 // Checks that given |map| is NOT deprecated, equals to given |new_map| and
 // matches expectations.
 struct CheckSameMap {
   void Check(Handle<Map> map, Handle<Map> new_map,
              const Expectations& expectations) {
     CHECK(!map->is_deprecated());
     CHECK_EQ(*map, *new_map);
 
     CHECK(!new_map->is_deprecated());
     CHECK(!new_map->is_dictionary_map());
     CHECK(expectations.Check(*new_map));
 
     // Update deprecated |map|, it should become |new_map|.
-    CHECK_EQ(*new_map, *Map::Update(map));
+    Handle<Map> updated_map = Map::Update(map);
+    CHECK_EQ(*new_map, *updated_map);
   }
 };
 
 
 // Checks that given |map| is NOT deprecated, and |new_map| is a result of
 // copy-generalize-all-representations.
 struct CheckCopyGeneralizeAllRepresentations {
   void Check(Handle<Map> map, Handle<Map> new_map, Expectations& expectations) {
     CHECK(!map->is_deprecated());
     CHECK_NE(*map, *new_map);
@@ skipping 394 matching lines @@
       CHECK(expectations.Check(*new_map2));
     }
   }
 
   Handle<Map> active_map = maps[kPropCount - 1];
   CHECK(!active_map->is_deprecated());
 
   // Update all deprecated maps and check that they are now the same.
   CHECK_EQ(*active_map, *Map::Update(map));
   for (int i = 0; i < kPropCount; i++) {
-    CHECK_EQ(*active_map, *Map::Update(maps[i]));
+    Handle<Map> updated_map = Map::Update(maps[i]);
+    CHECK_EQ(*active_map, *updated_map);
   }
 }
 
 
 TEST(ElementsKindTransitionFromMapOwningDescriptor) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<HeapType> any_type = HeapType::Any(isolate);
   Handle<HeapType> value_type =
@@ skipping 286 matching lines @@
       : descriptor_(descriptor),
         representation_(representation),
         attributes_(attributes),
         heap_type_(heap_type) {}
 
   void Check(Expectations& expectations2, Handle<Map> map1, Handle<Map> map2) {
     CHECK(!map2->is_deprecated());
 
     CHECK(map1->is_deprecated());
     CHECK_NE(*map1, *map2);
-    CHECK_EQ(*map2, *Map::Update(map1));
+    Handle<Map> updated_map = Map::Update(map1);
+    CHECK_EQ(*map2, *updated_map);
 
     expectations2.SetDataField(descriptor_, representation_, heap_type_);
     CHECK(expectations2.Check(*map2));
   }
 };
 
 
 // Checks that existing transition was taken as is.
 struct SameMapChecker {
   void Check(Expectations& expectations, Handle<Map> map1, Handle<Map> map2) {
@@ skipping 139 matching lines @@
   Handle<AccessorPair> pair = CreateAccessorPair(true, true);
   TransitionToAccessorConstantOperator transition_op(pair);
 
   SameMapChecker checker;
   TestTransitionTo(transition_op, transition_op, checker);
 }
 
 
 // TODO(ishell): add this test once IS_ACCESSOR_FIELD_SUPPORTED is supported.
 // TEST(TransitionAccessorConstantToAnotherAccessorConstant)