Revert of [runtime] Introduce dedicated JSBoundFunction to represent bound functions.

src/objects-inl.h

 // 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.
 //
 // Review notes:
 //
 // - The use of macros in these inline functions may seem superfluous
 // but it is absolutely needed to make sure gcc generates optimal
 // code. gcc is not happy when attempting to inline too deep.
 //
@@ skipping 169 matching lines @@
   return Object::IsHeapObject() &&
          HeapObject::cast(this)->map()->instance_type() <= LAST_NAME_TYPE;
 }
 
 
 bool Object::IsUniqueName() const {
   return IsInternalizedString() || IsSymbol();
 }
 
 
-bool Object::IsFunction() const {
-  STATIC_ASSERT(LAST_FUNCTION_TYPE == LAST_TYPE);
-  return Object::IsHeapObject() &&
-         HeapObject::cast(this)->map()->instance_type() >= FIRST_FUNCTION_TYPE;
-}
-
-
 bool Object::IsCallable() const {
   return Object::IsHeapObject() && HeapObject::cast(this)->map()->is_callable();
 }
 
 
 bool Object::IsConstructor() const {
   return Object::IsHeapObject() &&
          HeapObject::cast(this)->map()->is_constructor();
 }
 
@@ skipping 534 matching lines @@
 }
 
 
 bool Object::IsTypeFeedbackVector() const { return IsFixedArray(); }
 
 
 bool Object::IsTypeFeedbackMetadata() const { return IsFixedArray(); }
 
 
 bool Object::IsLiteralsArray() const { return IsFixedArray(); }
+bool Object::IsBindingsArray() const { return IsFixedArray(); }
 
 
 bool Object::IsDeoptimizationInputData() const {
   // Must be a fixed array.
   if (!IsFixedArray()) return false;
 
   // There's no sure way to detect the difference between a fixed array and
   // a deoptimization data array.  Since this is used for asserts we can
   // check that the length is zero or else the fixed size plus a multiple of
   // the entry size.
@@ skipping 60 matching lines @@
 }
 
 
 bool Object::IsScopeInfo() const {
   return Object::IsHeapObject() &&
       HeapObject::cast(this)->map() ==
       HeapObject::cast(this)->GetHeap()->scope_info_map();
 }
 
 
-TYPE_CHECKER(JSBoundFunction, JS_BOUND_FUNCTION_TYPE)
 TYPE_CHECKER(JSFunction, JS_FUNCTION_TYPE)
 
 
 template <> inline bool Is<JSFunction>(Object* obj) {
   return obj->IsJSFunction();
 }
 
 
 TYPE_CHECKER(Code, CODE_TYPE)
 TYPE_CHECKER(Oddball, ODDBALL_TYPE)
@@ skipping 1242 matching lines @@
   if (type == JS_OBJECT_TYPE) return JSObject::kHeaderSize;
   switch (type) {
     case JS_GENERATOR_OBJECT_TYPE:
       return JSGeneratorObject::kSize;
     case JS_MODULE_TYPE:
       return JSModule::kSize;
     case JS_GLOBAL_PROXY_TYPE:
       return JSGlobalProxy::kSize;
     case JS_GLOBAL_OBJECT_TYPE:
       return JSGlobalObject::kSize;
-    case JS_BOUND_FUNCTION_TYPE:
-      return JSBoundFunction::kSize;
     case JS_FUNCTION_TYPE:
       return JSFunction::kSize;
     case JS_VALUE_TYPE:
       return JSValue::kSize;
     case JS_DATE_TYPE:
       return JSDate::kSize;
     case JS_ARRAY_TYPE:
       return JSArray::kSize;
     case JS_ARRAY_BUFFER_TYPE:
       return JSArrayBuffer::kSize;
@@ skipping 1113 matching lines @@
 CAST_ACCESSOR(Foreign)
 CAST_ACCESSOR(GlobalDictionary)
 CAST_ACCESSOR(HandlerTable)
 CAST_ACCESSOR(HeapObject)
 CAST_ACCESSOR(Int16x8)
 CAST_ACCESSOR(Int32x4)
 CAST_ACCESSOR(Int8x16)
 CAST_ACCESSOR(JSArray)
 CAST_ACCESSOR(JSArrayBuffer)
 CAST_ACCESSOR(JSArrayBufferView)
-CAST_ACCESSOR(JSBoundFunction)
 CAST_ACCESSOR(JSDataView)
 CAST_ACCESSOR(JSDate)
 CAST_ACCESSOR(JSFunction)
 CAST_ACCESSOR(JSGeneratorObject)
 CAST_ACCESSOR(JSGlobalObject)
 CAST_ACCESSOR(JSGlobalProxy)
 CAST_ACCESSOR(JSMap)
 CAST_ACCESSOR(JSMapIterator)
 CAST_ACCESSOR(JSMessageObject)
 CAST_ACCESSOR(JSModule)
@@ skipping 183 matching lines @@
 void LiteralsArray::set_literal(int literal_index, Object* literal) {
   set(kFirstLiteralIndex + literal_index, literal);
 }
 
 
 int LiteralsArray::literals_count() const {
   return length() - kFirstLiteralIndex;
 }
 
 
+Object* BindingsArray::get(int index) const { return FixedArray::get(index); }
+
+
+void BindingsArray::set(int index, Object* value) {
+  FixedArray::set(index, value);
+}
+
+
+void BindingsArray::set(int index, Smi* value) {
+  FixedArray::set(index, value);
+}
+
+
+void BindingsArray::set(int index, Object* value, WriteBarrierMode mode) {
+  FixedArray::set(index, value, mode);
+}
+
+
+int BindingsArray::length() const { return FixedArray::length(); }
+
+
+BindingsArray* BindingsArray::cast(Object* object) {
+  SLOW_DCHECK(object->IsBindingsArray());
+  return reinterpret_cast<BindingsArray*>(object);
+}
+
+void BindingsArray::set_feedback_vector(TypeFeedbackVector* vector) {
+  set(kVectorIndex, vector);
+}
+
+
+TypeFeedbackVector* BindingsArray::feedback_vector() const {
+  return TypeFeedbackVector::cast(get(kVectorIndex));
+}
+
+
+JSReceiver* BindingsArray::bound_function() const {
+  return JSReceiver::cast(get(kBoundFunctionIndex));
+}
+
+
+void BindingsArray::set_bound_function(JSReceiver* function) {
+  set(kBoundFunctionIndex, function);
+}
+
+
+Object* BindingsArray::bound_this() const { return get(kBoundThisIndex); }
+
+
+void BindingsArray::set_bound_this(Object* bound_this) {
+  set(kBoundThisIndex, bound_this);
+}
+
+
+Object* BindingsArray::binding(int binding_index) const {
+  return get(kFirstBindingIndex + binding_index);
+}
+
+
+void BindingsArray::set_binding(int binding_index, Object* binding) {
+  set(kFirstBindingIndex + binding_index, binding);
+}
+
+
+int BindingsArray::bindings_count() const {
+  return length() - kFirstBindingIndex;
+}
+
+
 void HandlerTable::SetRangeStart(int index, int value) {
   set(index * kRangeEntrySize + kRangeStartIndex, Smi::FromInt(value));
 }
 
 
 void HandlerTable::SetRangeEnd(int index, int value) {
   set(index * kRangeEntrySize + kRangeEndIndex, Smi::FromInt(value));
 }
 
 
@@ skipping 1031 matching lines @@
     set_bit_field(bit_field() & ~(1 << kHasNonInstancePrototype));
   }
 }
 
 
 bool Map::has_non_instance_prototype() {
   return ((1 << kHasNonInstancePrototype) & bit_field()) != 0;
 }
 
 
-void Map::set_is_constructor() {
-  set_bit_field(bit_field() | (1 << kIsConstructor));
+void Map::set_is_constructor(bool value) {
+  if (value) {
+    set_bit_field(bit_field() | (1 << kIsConstructor));
+  } else {
+    set_bit_field(bit_field() & ~(1 << kIsConstructor));
+  }
 }
 
 
 bool Map::is_constructor() const {
   return ((1 << kIsConstructor) & bit_field()) != 0;
 }
 
 
 void Map::set_is_hidden_prototype() {
   set_bit_field3(IsHiddenPrototype::update(bit_field3(), true));
@@ skipping 965 matching lines @@
   set_constructor_or_backpointer(constructor, mode);
 }
 
 
 Handle<Map> Map::CopyInitialMap(Handle<Map> map) {
   return CopyInitialMap(map, map->instance_size(), map->GetInObjectProperties(),
                         map->unused_property_fields());
 }
 
 
-ACCESSORS(JSBoundFunction, length, Object, kLengthOffset)
-ACCESSORS(JSBoundFunction, name, Object, kNameOffset)
-ACCESSORS(JSBoundFunction, bound_target_function, JSReceiver,
-          kBoundTargetFunctionOffset)
-ACCESSORS(JSBoundFunction, bound_this, Object, kBoundThisOffset)
-ACCESSORS(JSBoundFunction, bound_arguments, FixedArray, kBoundArgumentsOffset)
-ACCESSORS(JSBoundFunction, creation_context, Context, kCreationContextOffset)
-
 ACCESSORS(JSFunction, shared, SharedFunctionInfo, kSharedFunctionInfoOffset)
-ACCESSORS(JSFunction, literals, LiteralsArray, kLiteralsOffset)
+ACCESSORS(JSFunction, literals_or_bindings, FixedArray, kLiteralsOffset)
 ACCESSORS(JSFunction, next_function_link, Object, kNextFunctionLinkOffset)
 
 ACCESSORS(JSGlobalObject, native_context, Context, kNativeContextOffset)
 ACCESSORS(JSGlobalObject, global_proxy, JSObject, kGlobalProxyOffset)
 
 ACCESSORS(JSGlobalProxy, native_context, Object, kNativeContextOffset)
 ACCESSORS(JSGlobalProxy, hash, Object, kHashOffset)
 
 ACCESSORS(AccessorInfo, name, Object, kNameOffset)
 SMI_ACCESSORS(AccessorInfo, flag, kFlagOffset)
@@ skipping 322 matching lines @@
 }
 
 
 BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, needs_home_object,
                kNeedsHomeObject)
 BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, native, kNative)
 BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, force_inline, kForceInline)
 BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints,
                name_should_print_as_anonymous,
                kNameShouldPrintAsAnonymous)
+BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, bound, kBoundFunction)
 BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, is_anonymous, kIsAnonymous)
 BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, is_function, kIsFunction)
 BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, dont_crankshaft,
                kDontCrankshaft)
 BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, dont_flush, kDontFlush)
 BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, is_arrow, kIsArrow)
 BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, is_generator, kIsGenerator)
 BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, is_concise_method,
                kIsConciseMethod)
 BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, is_accessor_function,
@@ skipping 424 matching lines @@
 
 
 bool JSFunction::is_compiled() {
   Builtins* builtins = GetIsolate()->builtins();
   return code() != builtins->builtin(Builtins::kCompileLazy) &&
          code() != builtins->builtin(Builtins::kCompileOptimized) &&
          code() != builtins->builtin(Builtins::kCompileOptimizedConcurrent);
 }
 
 
+LiteralsArray* JSFunction::literals() {
+  DCHECK(!shared()->bound());
+  return LiteralsArray::cast(literals_or_bindings());
+}
+
+
+void JSFunction::set_literals(LiteralsArray* literals) {
+  DCHECK(!shared()->bound());
+  set_literals_or_bindings(literals);
+}
+
+
+BindingsArray* JSFunction::function_bindings() {
+  DCHECK(shared()->bound());
+  return BindingsArray::cast(literals_or_bindings());
+}
+
+
+void JSFunction::set_function_bindings(BindingsArray* bindings) {
+  DCHECK(shared()->bound());
+  // Bound function literal may be initialized to the empty fixed array
+  // before the bindings are set.
+  DCHECK(bindings == GetHeap()->empty_fixed_array() ||
+         bindings->map() == GetHeap()->fixed_array_map());
+  set_literals_or_bindings(bindings);
+}
+
+
 int JSFunction::NumberOfLiterals() {
+  DCHECK(!shared()->bound());
   return literals()->length();
 }
 
 
 ACCESSORS(JSProxy, target, JSReceiver, kTargetOffset)
 ACCESSORS(JSProxy, handler, Object, kHandlerOffset)
 ACCESSORS(JSProxy, hash, Object, kHashOffset)
 
 bool JSProxy::IsRevoked() const { return !handler()->IsJSReceiver(); }
 
@@ skipping 1522 matching lines @@
 #undef WRITE_INT64_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 #undef NOBARRIER_READ_BYTE_FIELD
 #undef NOBARRIER_WRITE_BYTE_FIELD
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_OBJECTS_INL_H_