| // Copyright 2023 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. |
| |
| #ifndef V8_CODEGEN_CODE_STUB_ASSEMBLER_INL_H_ |
| #define V8_CODEGEN_CODE_STUB_ASSEMBLER_INL_H_ |
| |
| #include "src/codegen/code-stub-assembler.h" |
| // Include the non-inl header before the rest of the headers. |
| |
| #include <functional> |
| |
| #include "src/builtins/builtins-constructor-gen.h" |
| #include "src/builtins/builtins-inl.h" |
| #include "src/common/globals.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| #include "src/codegen/define-code-stub-assembler-macros.inc" |
| |
| template <typename TCallable, class... TArgs> |
| TNode<JSAny> CodeStubAssembler::Call(TNode<Context> context, |
| TNode<TCallable> callable, |
| ConvertReceiverMode mode, |
| TNode<JSAny> receiver, TArgs... args) { |
| static_assert(is_subtype_v<TCallable, Object>); |
| static_assert(!is_subtype_v<TCallable, JSFunction>, |
| "Use CallFunction() when the callable is a JSFunction."); |
| |
| if (IsUndefinedConstant(receiver) || IsNullConstant(receiver)) { |
| DCHECK_NE(mode, ConvertReceiverMode::kNotNullOrUndefined); |
| return CallJS(Builtins::Call(ConvertReceiverMode::kNullOrUndefined), |
| context, callable, receiver, args...); |
| } |
| DCheckReceiver(mode, receiver); |
| return CallJS(Builtins::Call(mode), context, callable, receiver, args...); |
| } |
| |
| template <typename TCallable, class... TArgs> |
| TNode<JSAny> CodeStubAssembler::Call(TNode<Context> context, |
| TNode<TCallable> callable, |
| TNode<JSReceiver> receiver, |
| TArgs... args) { |
| return Call(context, callable, ConvertReceiverMode::kNotNullOrUndefined, |
| receiver, args...); |
| } |
| |
| template <typename TCallable, class... TArgs> |
| TNode<JSAny> CodeStubAssembler::Call(TNode<Context> context, |
| TNode<TCallable> callable, |
| TNode<JSAny> receiver, TArgs... args) { |
| return Call(context, callable, ConvertReceiverMode::kAny, receiver, args...); |
| } |
| |
| template <class... TArgs> |
| TNode<JSAny> CodeStubAssembler::CallFunction(TNode<Context> context, |
| TNode<JSFunction> callable, |
| ConvertReceiverMode mode, |
| TNode<JSAny> receiver, |
| TArgs... args) { |
| if (IsUndefinedConstant(receiver) || IsNullConstant(receiver)) { |
| DCHECK_NE(mode, ConvertReceiverMode::kNotNullOrUndefined); |
| return CallJS(Builtins::CallFunction(ConvertReceiverMode::kNullOrUndefined), |
| context, callable, receiver, args...); |
| } |
| DCheckReceiver(mode, receiver); |
| return CallJS(Builtins::CallFunction(mode), context, callable, receiver, |
| args...); |
| } |
| |
| template <class... TArgs> |
| TNode<JSAny> CodeStubAssembler::CallFunction(TNode<Context> context, |
| TNode<JSFunction> callable, |
| TNode<JSReceiver> receiver, |
| TArgs... args) { |
| return CallFunction(context, callable, |
| ConvertReceiverMode::kNotNullOrUndefined, receiver, |
| args...); |
| } |
| |
| template <class... TArgs> |
| TNode<JSAny> CodeStubAssembler::CallFunction(TNode<Context> context, |
| TNode<JSFunction> callable, |
| TNode<JSAny> receiver, |
| TArgs... args) { |
| return CallFunction(context, callable, ConvertReceiverMode::kAny, receiver, |
| args...); |
| } |
| |
| template <typename Function> |
| TNode<Object> CodeStubAssembler::FastCloneJSObject( |
| TNode<HeapObject> object, TNode<Map> source_map, TNode<Map> target_map, |
| const Function& materialize_target, bool target_is_new) { |
| Label done_copy_properties(this), done_copy_elements(this); |
| |
| // This macro only suport JSObjects. |
| CSA_DCHECK(this, InstanceTypeEqual(LoadInstanceType(object), JS_OBJECT_TYPE)); |
| CSA_DCHECK(this, IsStrong(TNode<MaybeObject>(target_map))); |
| CSA_DCHECK( |
| this, InstanceTypeEqual(LoadMapInstanceType(target_map), JS_OBJECT_TYPE)); |
| // We do not want to deal with slack-tracking here. |
| CSA_DCHECK(this, IsNotSetWord32<Map::Bits3::ConstructionCounterBits>( |
| LoadMapBitField3(source_map))); |
| CSA_DCHECK(this, IsNotSetWord32<Map::Bits3::ConstructionCounterBits>( |
| LoadMapBitField3(target_map))); |
| |
| TVARIABLE((Union<FixedArray, PropertyArray>), var_properties, |
| EmptyFixedArrayConstant()); |
| TVARIABLE(FixedArray, var_elements, EmptyFixedArrayConstant()); |
| |
| // Copy the PropertyArray backing store. The source PropertyArray |
| // must be either an Smi, or a PropertyArray. |
| Comment("FastCloneJSObject: cloning properties"); |
| TNode<Object> source_properties = |
| LoadObjectField(object, JSObject::kPropertiesOrHashOffset); |
| { |
| GotoIf(TaggedIsSmi(source_properties), &done_copy_properties); |
| GotoIf(IsEmptyFixedArray(source_properties), &done_copy_properties); |
| |
| // This fastcase requires that the source object has fast properties. |
| TNode<PropertyArray> source_property_array = CAST(source_properties); |
| |
| TNode<IntPtrT> length = LoadPropertyArrayLength(source_property_array); |
| GotoIf(IntPtrEqual(length, IntPtrConstant(0)), &done_copy_properties); |
| |
| TNode<PropertyArray> property_array = AllocatePropertyArray(length); |
| FillPropertyArrayWithUndefined(property_array, IntPtrConstant(0), length); |
| CopyPropertyArrayValues(source_property_array, property_array, length, |
| SKIP_WRITE_BARRIER, DestroySource::kNo); |
| var_properties = property_array; |
| } |
| |
| Goto(&done_copy_properties); |
| BIND(&done_copy_properties); |
| |
| Comment("FastCloneJSObject: cloning elements"); |
| TNode<FixedArrayBase> source_elements = LoadElements(CAST(object)); |
| GotoIf(TaggedEqual(source_elements, EmptyFixedArrayConstant()), |
| &done_copy_elements); |
| var_elements = CAST(CloneFixedArray( |
| source_elements, ExtractFixedArrayFlag::kAllFixedArraysDontCopyCOW)); |
| |
| Goto(&done_copy_elements); |
| BIND(&done_copy_elements); |
| |
| Comment("FastCloneJSObject: initialize the target object"); |
| TNode<JSReceiver> target = materialize_target( |
| target_map, var_properties.value(), var_elements.value()); |
| |
| // Lastly, clone any in-object properties. |
| #ifdef DEBUG |
| { |
| TNode<IntPtrT> source_used_instance_size = |
| MapUsedInstanceSizeInWords(source_map); |
| TNode<IntPtrT> target_used_instance_size = |
| MapUsedInstanceSizeInWords(target_map); |
| TNode<IntPtrT> source_inobject_properties_start = |
| LoadMapInobjectPropertiesStartInWords(source_map); |
| TNode<IntPtrT> target_inobject_properties_start = |
| LoadMapInobjectPropertiesStartInWords(target_map); |
| CSA_DCHECK(this, IntPtrEqual(IntPtrSub(target_used_instance_size, |
| target_inobject_properties_start), |
| IntPtrSub(source_used_instance_size, |
| source_inobject_properties_start))); |
| } |
| #endif // DEBUG |
| |
| // 1) Initialize unused in-object properties. |
| Comment("FastCloneJSObject: initializing unused in-object properties"); |
| TNode<IntPtrT> target_used_payload_end = |
| TimesTaggedSize(MapUsedInstanceSizeInWords(target_map)); |
| TNode<IntPtrT> target_payload_end = |
| TimesTaggedSize(LoadMapInstanceSizeInWords(target_map)); |
| InitializeFieldsWithRoot(target, target_used_payload_end, target_payload_end, |
| RootIndex::kUndefinedValue); |
| |
| // 2) Copy all used in-object properties. |
| Comment("FastCloneJSObject: copying used in-object properties"); |
| TNode<IntPtrT> source_payload_start = |
| TimesTaggedSize(LoadMapInobjectPropertiesStartInWords(source_map)); |
| TNode<IntPtrT> target_payload_start = |
| TimesTaggedSize(LoadMapInobjectPropertiesStartInWords(target_map)); |
| TNode<IntPtrT> field_offset_difference = |
| IntPtrSub(source_payload_start, target_payload_start); |
| |
| Label done_copy_used(this); |
| auto EmitCopyLoop = [&](bool write_barrier) { |
| if (write_barrier) { |
| Comment( |
| "FastCloneJSObject: copying used in-object properties with write " |
| "barrier"); |
| } else { |
| Comment( |
| "FastCloneJSObject: copying used in-object properties without write " |
| "barrier"); |
| } |
| BuildFastLoop<IntPtrT>( |
| target_payload_start, target_used_payload_end, |
| [&](TNode<IntPtrT> result_offset) { |
| TNode<IntPtrT> source_offset = |
| IntPtrSub(result_offset, field_offset_difference); |
| if (write_barrier) { |
| TNode<Object> field = LoadObjectField(object, source_offset); |
| StoreObjectField(target, result_offset, field); |
| } else { |
| TNode<TaggedT> field = |
| LoadObjectField<TaggedT>(object, source_offset); |
| StoreObjectFieldNoWriteBarrier(target, result_offset, field); |
| } |
| }, |
| kTaggedSize, LoopUnrollingMode::kYes, IndexAdvanceMode::kPost); |
| }; |
| |
| if (!target_is_new) { |
| Label if_no_write_barrier(this), |
| if_needs_write_barrier(this, Label::kDeferred); |
| |
| TrySkipWriteBarrier(target, &if_needs_write_barrier); |
| Goto(&if_no_write_barrier); |
| |
| BIND(&if_needs_write_barrier); |
| EmitCopyLoop(true); |
| |
| Goto(&done_copy_used); |
| BIND(&if_no_write_barrier); |
| } |
| |
| EmitCopyLoop(false); |
| Goto(&done_copy_used); |
| |
| BIND(&done_copy_used); |
| |
| // 3) Duplicate heap number boxes if needed. |
| // We need to go through the {object} again here and properly clone |
| // them. We use a second loop here to ensure that the GC (and heap |
| // verifier) always sees properly initialized objects, i.e. never |
| // hits undefined values in double fields. |
| Comment("FastCloneJSObject: cloning heap numbers"); |
| ConstructorBuiltinsAssembler(state()).CopyMutableHeapNumbersInObject( |
| target, target_payload_start, target_used_payload_end); |
| |
| return target; |
| } |
| |
| #include "src/codegen/undef-code-stub-assembler-macros.inc" |
| |
| } // namespace internal |
| } // namespace v8 |
| |
| #endif // V8_CODEGEN_CODE_STUB_ASSEMBLER_INL_H_ |
