Move Maps' back pointers from "transitions" to "constructor" field

src/isolate.cc

 // Copyright 2012 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 <fstream>  // NOLINT(readability/streams)
 #include <sstream>
 
 #include "src/v8.h"
@@ skipping 593 matching lines @@
   Handle<JSArray> stack_trace = factory()->NewJSArray(frame_limit);
   for (int i = 1; i < elements_limit && frames_seen < frame_limit; i += 4) {
     Handle<Object> recv = handle(elements->get(i), this);
     Handle<JSFunction> fun =
         handle(JSFunction::cast(elements->get(i + 1)), this);
     Handle<Code> code = handle(Code::cast(elements->get(i + 2)), this);
     Handle<Smi> offset = handle(Smi::cast(elements->get(i + 3)), this);
     Address pc = code->address() + offset->value();
     bool is_constructor =
         recv->IsJSObject() &&
-        Handle<JSObject>::cast(recv)->map()->constructor() == *fun;
+        Handle<JSObject>::cast(recv)->map()->GetConstructor() == *fun;
 
     Handle<JSObject> stack_frame =
         helper.NewStackFrameObject(fun, code, pc, is_constructor);
 
     FixedArray::cast(stack_trace->elements())->set(frames_seen, *stack_frame);
     frames_seen++;
   }
 
   stack_trace->set_length(Smi::FromInt(frames_seen));
   return stack_trace;
@@ skipping 92 matching lines @@
 
 
 void Isolate::SetFailedAccessCheckCallback(
     v8::FailedAccessCheckCallback callback) {
   thread_local_top()->failed_access_check_callback_ = callback;
 }
 
 
 static inline AccessCheckInfo* GetAccessCheckInfo(Isolate* isolate,
                                                   Handle<JSObject> receiver) {
-  JSFunction* constructor = JSFunction::cast(receiver->map()->constructor());
+  JSFunction* constructor = JSFunction::cast(receiver->map()->GetConstructor());
   if (!constructor->shared()->IsApiFunction()) return NULL;
 
   Object* data_obj =
      constructor->shared()->get_api_func_data()->access_check_info();
   if (data_obj == isolate->heap()->undefined_value()) return NULL;
 
   return AccessCheckInfo::cast(data_obj);
 }
 
 
@@ skipping 424 matching lines @@
 
   Handle<String> error_key =
       factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("$Error"));
   Handle<Object> error_constructor = Object::GetProperty(
       js_builtins_object(), error_key).ToHandleChecked();
 
   DisallowHeapAllocation no_gc;
   for (PrototypeIterator iter(this, *obj, PrototypeIterator::START_AT_RECEIVER);
        !iter.IsAtEnd(); iter.Advance()) {
     if (iter.GetCurrent()->IsJSProxy()) return false;
-    if (JSObject::cast(iter.GetCurrent())->map()->constructor() ==
+    if (JSObject::cast(iter.GetCurrent())->map()->GetConstructor() ==
         *error_constructor) {
       return true;
     }
   }
   return false;
 }
 
 static int fatal_exception_depth = 0;
 
 
@@ skipping 1424 matching lines @@
   if (prev_ && prev_->Intercept(flag)) return true;
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 } }  // namespace v8::internal