Revert of making heap verification more aggressive

src/runtime/runtime-literals.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 "src/runtime/runtime-utils.h"
 
 #include "src/allocation-site-scopes.h"
 #include "src/arguments.h"
 #include "src/ast/ast.h"
 #include "src/isolate-inl.h"
@@ skipping 96 matching lines @@
     JSObject::MigrateSlowToFast(boilerplate,
                                 boilerplate->map()->unused_property_fields(),
                                 "FastLiteral");
   }
   return boilerplate;
 }
 
 static MaybeHandle<Object> CreateArrayLiteralBoilerplate(
     Isolate* isolate, Handle<LiteralsArray> literals,
     Handle<FixedArray> elements) {
+  // Create the JSArray.
+  Handle<JSFunction> constructor = isolate->array_function();
+
+  PretenureFlag pretenure_flag =
+      isolate->heap()->InNewSpace(*literals) ? NOT_TENURED : TENURED;
+
+  Handle<JSArray> object = Handle<JSArray>::cast(
+      isolate->factory()->NewJSObject(constructor, pretenure_flag));
+
   ElementsKind constant_elements_kind =
       static_cast<ElementsKind>(Smi::cast(elements->get(0))->value());
-  DCHECK(IsFastElementsKind(constant_elements_kind));
   Handle<FixedArrayBase> constant_elements_values(
       FixedArrayBase::cast(elements->get(1)));
+
+  {
+    DisallowHeapAllocation no_gc;
+    DCHECK(IsFastElementsKind(constant_elements_kind));
+    Context* native_context = isolate->context()->native_context();
+    Object* map =
+        native_context->get(Context::ArrayMapIndex(constant_elements_kind));
+    object->set_map(Map::cast(map));
+  }
+
   Handle<FixedArrayBase> copied_elements_values;
-
   if (IsFastDoubleElementsKind(constant_elements_kind)) {
     copied_elements_values = isolate->factory()->CopyFixedDoubleArray(
         Handle<FixedDoubleArray>::cast(constant_elements_values));
   } else {
     DCHECK(IsFastSmiOrObjectElementsKind(constant_elements_kind));
     const bool is_cow = (constant_elements_values->map() ==
                          isolate->heap()->fixed_cow_array_map());
     if (is_cow) {
       copied_elements_values = constant_elements_values;
 #if DEBUG
@@ skipping 18 matching lines @@
                   FixedArray::cast(fixed_array_values->get(i)));
               Handle<Object> result;
               ASSIGN_RETURN_ON_EXCEPTION(
                   isolate, result,
                   CreateLiteralBoilerplate(isolate, literals, fa), Object);
               fixed_array_values_copy->set(i, *result);
             }
           });
     }
   }
-  // Create the JSArray.
-  PretenureFlag pretenure_flag =
-      isolate->heap()->InNewSpace(*literals) ? NOT_TENURED : TENURED;
-  Handle<JSArray> object = isolate->factory()->NewJSArrayWithElements(
-      copied_elements_values, constant_elements_kind,
-      copied_elements_values->length(), pretenure_flag);
+  object->set_elements(*copied_elements_values);
+  object->set_length(Smi::FromInt(copied_elements_values->length()));
+
   JSObject::ValidateElements(object);
   return object;
 }
 
 MUST_USE_RESULT static MaybeHandle<Object> CreateLiteralBoilerplate(
     Isolate* isolate, Handle<LiteralsArray> literals,
     Handle<FixedArray> array) {
   Handle<FixedArray> elements = CompileTimeValue::GetElements(array);
   switch (CompileTimeValue::GetLiteralType(array)) {
     case CompileTimeValue::OBJECT_LITERAL_FAST_ELEMENTS:
@@ skipping 155 matching lines @@
 
   Handle<LiteralsArray> literals(closure->literals(), isolate);
   RETURN_RESULT_OR_FAILURE(
       isolate,
       CreateArrayLiteralImpl(isolate, literals, literals_index, elements,
                              ArrayLiteral::kShallowElements));
 }
 
 }  // namespace internal
 }  // namespace v8