From 8792cac5cc250470cf1972ff634501bdbc93ddb5 Mon Sep 17 00:00:00 2001 From: "hpayer@chromium.org" Date: Mon, 25 Mar 2013 15:54:15 +0000 Subject: [PATCH] Generalizing remaining Allocate functions in the macro assemblers used in pretenuring. BUG= Review URL: https://codereview.chromium.org/12440041 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@14065 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/arm/builtins-arm.cc | 17 ++++---- src/arm/code-stubs-arm.cc | 13 ++---- src/arm/codegen-arm.cc | 4 +- src/arm/lithium-codegen-arm.cc | 12 +++--- src/arm/macro-assembler-arm.cc | 52 ++++++++++++------------ src/arm/macro-assembler-arm.h | 12 +++--- src/arm/stub-cache-arm.cc | 2 +- src/ia32/builtins-ia32.cc | 39 +++++++++--------- src/ia32/code-stubs-ia32.cc | 22 +++++----- src/ia32/codegen-ia32.cc | 7 ++-- src/ia32/lithium-codegen-ia32.cc | 2 +- src/ia32/macro-assembler-ia32.cc | 88 ++++++++++++++++++++-------------------- src/ia32/macro-assembler-ia32.h | 32 +++++++-------- src/x64/builtins-x64.cc | 44 ++++++++++---------- src/x64/code-stubs-x64.cc | 20 ++++----- src/x64/codegen-x64.cc | 4 +- src/x64/lithium-codegen-x64.cc | 2 +- src/x64/macro-assembler-x64.cc | 74 ++++++++++++++++----------------- src/x64/macro-assembler-x64.h | 28 ++++++------- 19 files changed, 232 insertions(+), 242 deletions(-) diff --git a/src/arm/builtins-arm.cc b/src/arm/builtins-arm.cc index 98a4c0b..ebb9e12 100644 --- a/src/arm/builtins-arm.cc +++ b/src/arm/builtins-arm.cc @@ -221,13 +221,12 @@ static void AllocateJSArray(MacroAssembler* masm, __ add(elements_array_end, elements_array_end, Operand(array_size, ASR, kSmiTagSize)); - __ AllocateInNewSpace( - elements_array_end, - result, - scratch1, - scratch2, - gc_required, - static_cast(TAG_OBJECT | SIZE_IN_WORDS)); + __ Allocate(elements_array_end, + result, + scratch1, + scratch2, + gc_required, + static_cast(TAG_OBJECT | SIZE_IN_WORDS)); // Allocated the JSArray. Now initialize the fields except for the elements // array. @@ -874,7 +873,7 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm, // r1: constructor function // r2: initial map __ ldrb(r3, FieldMemOperand(r2, Map::kInstanceSizeOffset)); - __ AllocateInNewSpace(r3, r4, r5, r6, &rt_call, SIZE_IN_WORDS); + __ Allocate(r3, r4, r5, r6, &rt_call, SIZE_IN_WORDS); // Allocated the JSObject, now initialize the fields. Map is set to // initial map and properties and elements are set to empty fixed array. @@ -949,7 +948,7 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm, // r4: JSObject // r5: start of next object __ add(r0, r3, Operand(FixedArray::kHeaderSize / kPointerSize)); - __ AllocateInNewSpace( + __ Allocate( r0, r5, r6, diff --git a/src/arm/code-stubs-arm.cc b/src/arm/code-stubs-arm.cc index 9fab908..d5db837 100644 --- a/src/arm/code-stubs-arm.cc +++ b/src/arm/code-stubs-arm.cc @@ -4791,7 +4791,7 @@ void ArgumentsAccessStub::GenerateNewNonStrictFast(MacroAssembler* masm) { __ add(r9, r9, Operand(Heap::kArgumentsObjectSize)); // Do the allocation of all three objects in one go. - __ AllocateInNewSpace(r9, r0, r3, r4, &runtime, TAG_OBJECT); + __ Allocate(r9, r0, r3, r4, &runtime, TAG_OBJECT); // r0 = address of new object(s) (tagged) // r2 = argument count (tagged) @@ -4967,13 +4967,8 @@ void ArgumentsAccessStub::GenerateNewStrict(MacroAssembler* masm) { __ add(r1, r1, Operand(Heap::kArgumentsObjectSizeStrict / kPointerSize)); // Do the allocation of both objects in one go. - __ AllocateInNewSpace(r1, - r0, - r2, - r3, - &runtime, - static_cast(TAG_OBJECT | - SIZE_IN_WORDS)); + __ Allocate(r1, r0, r2, r3, &runtime, + static_cast(TAG_OBJECT | SIZE_IN_WORDS)); // Get the arguments boilerplate from the current native context. __ ldr(r4, MemOperand(cp, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX))); @@ -5477,7 +5472,7 @@ void RegExpConstructResultStub::Generate(MacroAssembler* masm) { (JSRegExpResult::kSize + FixedArray::kHeaderSize) / kPointerSize; __ mov(r5, Operand(r1, LSR, kSmiTagSize + kSmiShiftSize)); __ add(r2, r5, Operand(objects_size)); - __ AllocateInNewSpace( + __ Allocate( r2, // In: Size, in words. r0, // Out: Start of allocation (tagged). r3, // Scratch register. diff --git a/src/arm/codegen-arm.cc b/src/arm/codegen-arm.cc index b8f8f6d..1c82946 100644 --- a/src/arm/codegen-arm.cc +++ b/src/arm/codegen-arm.cc @@ -207,7 +207,7 @@ void ElementsTransitionGenerator::GenerateSmiToDouble( // Use lr as a temporary register. __ mov(lr, Operand(r5, LSL, 2)); __ add(lr, lr, Operand(FixedDoubleArray::kHeaderSize)); - __ AllocateInNewSpace(lr, r6, r7, r9, &gc_required, DOUBLE_ALIGNMENT); + __ Allocate(lr, r6, r7, r9, &gc_required, DOUBLE_ALIGNMENT); // r6: destination FixedDoubleArray, not tagged as heap object. // Set destination FixedDoubleArray's length and map. @@ -348,7 +348,7 @@ void ElementsTransitionGenerator::GenerateDoubleToObject( // Allocate new FixedArray. __ mov(r0, Operand(FixedDoubleArray::kHeaderSize)); __ add(r0, r0, Operand(r5, LSL, 1)); - __ AllocateInNewSpace(r0, r6, r7, r9, &gc_required, NO_ALLOCATION_FLAGS); + __ Allocate(r0, r6, r7, r9, &gc_required, NO_ALLOCATION_FLAGS); // r6: destination FixedArray, not tagged as heap object // Set destination FixedDoubleArray's length and map. __ LoadRoot(r9, Heap::kFixedArrayMapRootIndex); diff --git a/src/arm/lithium-codegen-arm.cc b/src/arm/lithium-codegen-arm.cc index f65042e..041aa3f 100644 --- a/src/arm/lithium-codegen-arm.cc +++ b/src/arm/lithium-codegen-arm.cc @@ -5677,12 +5677,12 @@ void LCodeGen::DoAllocate(LAllocate* instr) { __ Allocate(size, result, scratch, scratch2, deferred->entry(), flags); } else { Register size = ToRegister(instr->size()); - __ AllocateInNewSpace(size, - result, - scratch, - scratch2, - deferred->entry(), - flags); + __ Allocate(size, + result, + scratch, + scratch2, + deferred->entry(), + flags); } __ bind(deferred->exit()); diff --git a/src/arm/macro-assembler-arm.cc b/src/arm/macro-assembler-arm.cc index e0e77cf..8a53174 100644 --- a/src/arm/macro-assembler-arm.cc +++ b/src/arm/macro-assembler-arm.cc @@ -1671,13 +1671,12 @@ void MacroAssembler::Allocate(int object_size, } -void MacroAssembler::AllocateInNewSpace(Register object_size, - Register result, - Register scratch1, - Register scratch2, - Label* gc_required, - AllocationFlags flags) { - ASSERT((flags & PRETENURE_OLD_POINTER_SPACE) == 0); +void MacroAssembler::Allocate(Register object_size, + Register result, + Register scratch1, + Register scratch2, + Label* gc_required, + AllocationFlags flags) { if (!FLAG_inline_new) { if (emit_debug_code()) { // Trash the registers to simulate an allocation failure. @@ -1703,20 +1702,20 @@ void MacroAssembler::AllocateInNewSpace(Register object_size, // The values must be adjacent in memory to allow the use of LDM. // Also, assert that the registers are numbered such that the values // are loaded in the correct order. - ExternalReference new_space_allocation_top = - ExternalReference::new_space_allocation_top_address(isolate()); - ExternalReference new_space_allocation_limit = - ExternalReference::new_space_allocation_limit_address(isolate()); + ExternalReference allocation_top = + AllocationUtils::GetAllocationTopReference(isolate(), flags); + ExternalReference allocation_limit = + AllocationUtils::GetAllocationLimitReference(isolate(), flags); intptr_t top = - reinterpret_cast(new_space_allocation_top.address()); + reinterpret_cast(allocation_top.address()); intptr_t limit = - reinterpret_cast(new_space_allocation_limit.address()); + reinterpret_cast(allocation_limit.address()); ASSERT((limit - top) == kPointerSize); ASSERT(result.code() < ip.code()); // Set up allocation top address. Register topaddr = scratch1; - mov(topaddr, Operand(new_space_allocation_top)); + mov(topaddr, Operand(allocation_top)); // This code stores a temporary value in ip. This is OK, as the code below // does not need ip for implicit literal generation. @@ -1739,6 +1738,7 @@ void MacroAssembler::AllocateInNewSpace(Register object_size, if ((flags & DOUBLE_ALIGNMENT) != 0) { // Align the next allocation. Storing the filler map without checking top is // always safe because the limit of the heap is always aligned. + ASSERT((flags & PRETENURE_OLD_POINTER_SPACE) == 0); ASSERT(kPointerAlignment * 2 == kDoubleAlignment); and_(scratch2, result, Operand(kDoubleAlignmentMask), SetCC); Label aligned; @@ -1809,12 +1809,12 @@ void MacroAssembler::AllocateTwoByteString(Register result, and_(scratch1, scratch1, Operand(~kObjectAlignmentMask)); // Allocate two-byte string in new space. - AllocateInNewSpace(scratch1, - result, - scratch2, - scratch3, - gc_required, - TAG_OBJECT); + Allocate(scratch1, + result, + scratch2, + scratch3, + gc_required, + TAG_OBJECT); // Set the map, length and hash field. InitializeNewString(result, @@ -1840,12 +1840,12 @@ void MacroAssembler::AllocateAsciiString(Register result, and_(scratch1, scratch1, Operand(~kObjectAlignmentMask)); // Allocate ASCII string in new space. - AllocateInNewSpace(scratch1, - result, - scratch2, - scratch3, - gc_required, - TAG_OBJECT); + Allocate(scratch1, + result, + scratch2, + scratch3, + gc_required, + TAG_OBJECT); // Set the map, length and hash field. InitializeNewString(result, diff --git a/src/arm/macro-assembler-arm.h b/src/arm/macro-assembler-arm.h index 5cbe995..ac7efdb 100644 --- a/src/arm/macro-assembler-arm.h +++ b/src/arm/macro-assembler-arm.h @@ -679,12 +679,12 @@ class MacroAssembler: public Assembler { Label* gc_required, AllocationFlags flags); - void AllocateInNewSpace(Register object_size, - Register result, - Register scratch1, - Register scratch2, - Label* gc_required, - AllocationFlags flags); + void Allocate(Register object_size, + Register result, + Register scratch1, + Register scratch2, + Label* gc_required, + AllocationFlags flags); // Undo allocation in new space. The object passed and objects allocated after // it will no longer be allocated. The caller must make sure that no pointers diff --git a/src/arm/stub-cache-arm.cc b/src/arm/stub-cache-arm.cc index b98b4e5..f2d45e1 100644 --- a/src/arm/stub-cache-arm.cc +++ b/src/arm/stub-cache-arm.cc @@ -2995,7 +2995,7 @@ Handle ConstructStubCompiler::CompileConstructStub( __ cmp(r3, Operand(instance_size >> kPointerSizeLog2)); __ Check(eq, "Instance size of initial map changed."); #endif - __ AllocateInNewSpace(r3, r4, r5, r6, &generic_stub_call, SIZE_IN_WORDS); + __ Allocate(r3, r4, r5, r6, &generic_stub_call, SIZE_IN_WORDS); // Allocated the JSObject, now initialize the fields. Map is set to initial // map and properties and elements are set to empty fixed array. diff --git a/src/ia32/builtins-ia32.cc b/src/ia32/builtins-ia32.cc index ff5ee53..e861db3 100644 --- a/src/ia32/builtins-ia32.cc +++ b/src/ia32/builtins-ia32.cc @@ -216,8 +216,7 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm, // eax: initial map __ movzx_b(edi, FieldOperand(eax, Map::kInstanceSizeOffset)); __ shl(edi, kPointerSizeLog2); - __ AllocateInNewSpace( - edi, ebx, edi, no_reg, &rt_call, NO_ALLOCATION_FLAGS); + __ Allocate(edi, ebx, edi, no_reg, &rt_call, NO_ALLOCATION_FLAGS); // Allocated the JSObject, now initialize the fields. // eax: initial map // ebx: JSObject @@ -280,15 +279,15 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm, // ebx: JSObject // edi: start of next object (will be start of FixedArray) // edx: number of elements in properties array - __ AllocateInNewSpace(FixedArray::kHeaderSize, - times_pointer_size, - edx, - REGISTER_VALUE_IS_INT32, - edi, - ecx, - no_reg, - &undo_allocation, - RESULT_CONTAINS_TOP); + __ Allocate(FixedArray::kHeaderSize, + times_pointer_size, + edx, + REGISTER_VALUE_IS_INT32, + edi, + ecx, + no_reg, + &undo_allocation, + RESULT_CONTAINS_TOP); // Initialize the FixedArray. // ebx: JSObject @@ -1125,15 +1124,15 @@ static void AllocateJSArray(MacroAssembler* masm, // Allocate the JSArray object together with space for a FixedArray with the // requested elements. STATIC_ASSERT(kSmiTagSize == 1 && kSmiTag == 0); - __ AllocateInNewSpace(JSArray::kSize + FixedArray::kHeaderSize, - times_pointer_size, - array_size, - REGISTER_VALUE_IS_SMI, - result, - elements_array_end, - scratch, - gc_required, - TAG_OBJECT); + __ Allocate(JSArray::kSize + FixedArray::kHeaderSize, + times_pointer_size, + array_size, + REGISTER_VALUE_IS_SMI, + result, + elements_array_end, + scratch, + gc_required, + TAG_OBJECT); // Allocated the JSArray. Now initialize the fields except for the elements // array. diff --git a/src/ia32/code-stubs-ia32.cc b/src/ia32/code-stubs-ia32.cc index 70d507a..a23f44a 100644 --- a/src/ia32/code-stubs-ia32.cc +++ b/src/ia32/code-stubs-ia32.cc @@ -3577,7 +3577,7 @@ void ArgumentsAccessStub::GenerateNewNonStrictFast(MacroAssembler* masm) { __ add(ebx, Immediate(Heap::kArgumentsObjectSize)); // Do the allocation of all three objects in one go. - __ AllocateInNewSpace(ebx, eax, edx, edi, &runtime, TAG_OBJECT); + __ Allocate(ebx, eax, edx, edi, &runtime, TAG_OBJECT); // eax = address of new object(s) (tagged) // ecx = argument count (tagged) @@ -3775,7 +3775,7 @@ void ArgumentsAccessStub::GenerateNewStrict(MacroAssembler* masm) { __ add(ecx, Immediate(Heap::kArgumentsObjectSizeStrict)); // Do the allocation of both objects in one go. - __ AllocateInNewSpace(ecx, eax, edx, ebx, &runtime, TAG_OBJECT); + __ Allocate(ecx, eax, edx, ebx, &runtime, TAG_OBJECT); // Get the arguments boilerplate from the current native context. __ mov(edi, Operand(esi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX))); @@ -4299,15 +4299,15 @@ void RegExpConstructResultStub::Generate(MacroAssembler* masm) { // Allocate RegExpResult followed by FixedArray with size in ebx. // JSArray: [Map][empty properties][Elements][Length-smi][index][input] // Elements: [Map][Length][..elements..] - __ AllocateInNewSpace(JSRegExpResult::kSize + FixedArray::kHeaderSize, - times_pointer_size, - ebx, // In: Number of elements as a smi - REGISTER_VALUE_IS_SMI, - eax, // Out: Start of allocation (tagged). - ecx, // Out: End of allocation. - edx, // Scratch register - &slowcase, - TAG_OBJECT); + __ Allocate(JSRegExpResult::kSize + FixedArray::kHeaderSize, + times_pointer_size, + ebx, // In: Number of elements as a smi + REGISTER_VALUE_IS_SMI, + eax, // Out: Start of allocation (tagged). + ecx, // Out: End of allocation. + edx, // Scratch register + &slowcase, + TAG_OBJECT); // eax: Start of allocated area, object-tagged. // Set JSArray map to global.regexp_result_map(). diff --git a/src/ia32/codegen-ia32.cc b/src/ia32/codegen-ia32.cc index 586ffef..550c83d 100644 --- a/src/ia32/codegen-ia32.cc +++ b/src/ia32/codegen-ia32.cc @@ -450,9 +450,8 @@ void ElementsTransitionGenerator::GenerateSmiToDouble( // edi: length of source FixedArray (smi-tagged) AllocationFlags flags = static_cast(TAG_OBJECT | DOUBLE_ALIGNMENT); - __ AllocateInNewSpace(FixedDoubleArray::kHeaderSize, times_8, - edi, REGISTER_VALUE_IS_SMI, - eax, ebx, no_reg, &gc_required, flags); + __ Allocate(FixedDoubleArray::kHeaderSize, times_8, edi, + REGISTER_VALUE_IS_SMI, eax, ebx, no_reg, &gc_required, flags); // eax: destination FixedDoubleArray // edi: number of elements @@ -589,7 +588,7 @@ void ElementsTransitionGenerator::GenerateDoubleToObject( // Allocate new FixedArray. // ebx: length of source FixedDoubleArray (smi-tagged) __ lea(edi, Operand(ebx, times_2, FixedArray::kHeaderSize)); - __ AllocateInNewSpace(edi, eax, esi, no_reg, &gc_required, TAG_OBJECT); + __ Allocate(edi, eax, esi, no_reg, &gc_required, TAG_OBJECT); // eax: destination FixedArray // ebx: number of elements diff --git a/src/ia32/lithium-codegen-ia32.cc b/src/ia32/lithium-codegen-ia32.cc index 588b6b6..e0e0254 100644 --- a/src/ia32/lithium-codegen-ia32.cc +++ b/src/ia32/lithium-codegen-ia32.cc @@ -5572,7 +5572,7 @@ void LCodeGen::DoAllocate(LAllocate* instr) { __ Allocate(size, result, temp, no_reg, deferred->entry(), flags); } else { Register size = ToRegister(instr->size()); - __ AllocateInNewSpace(size, result, temp, no_reg, deferred->entry(), flags); + __ Allocate(size, result, temp, no_reg, deferred->entry(), flags); } __ bind(deferred->exit()); diff --git a/src/ia32/macro-assembler-ia32.cc b/src/ia32/macro-assembler-ia32.cc index debf64a..3d3dabc 100644 --- a/src/ia32/macro-assembler-ia32.cc +++ b/src/ia32/macro-assembler-ia32.cc @@ -1332,18 +1332,16 @@ void MacroAssembler::Allocate(int object_size, } -void MacroAssembler::AllocateInNewSpace( - int header_size, - ScaleFactor element_size, - Register element_count, - RegisterValueType element_count_type, - Register result, - Register result_end, - Register scratch, - Label* gc_required, - AllocationFlags flags) { +void MacroAssembler::Allocate(int header_size, + ScaleFactor element_size, + Register element_count, + RegisterValueType element_count_type, + Register result, + Register result_end, + Register scratch, + Label* gc_required, + AllocationFlags flags) { ASSERT((flags & SIZE_IN_WORDS) == 0); - ASSERT((flags & PRETENURE_OLD_POINTER_SPACE) == 0); if (!FLAG_inline_new) { if (emit_debug_code()) { // Trash the registers to simulate an allocation failure. @@ -1365,6 +1363,7 @@ void MacroAssembler::AllocateInNewSpace( // Align the next allocation. Storing the filler map without checking top is // always safe because the limit of the heap is always aligned. if ((flags & DOUBLE_ALIGNMENT) != 0) { + ASSERT((flags & PRETENURE_OLD_POINTER_SPACE) == 0); ASSERT(kPointerAlignment * 2 == kDoubleAlignment); Label aligned; test(result, Immediate(kDoubleAlignmentMask)); @@ -1375,9 +1374,9 @@ void MacroAssembler::AllocateInNewSpace( bind(&aligned); } - // Calculate new top and bail out if new space is exhausted. - ExternalReference new_space_allocation_limit = - ExternalReference::new_space_allocation_limit_address(isolate()); + // Calculate new top and bail out if space is exhausted. + ExternalReference allocation_limit = + AllocationUtils::GetAllocationLimitReference(isolate(), flags); // We assume that element_count*element_size + header_size does not // overflow. @@ -1394,7 +1393,7 @@ void MacroAssembler::AllocateInNewSpace( lea(result_end, Operand(element_count, element_size, header_size)); add(result_end, result); j(carry, gc_required); - cmp(result_end, Operand::StaticVariable(new_space_allocation_limit)); + cmp(result_end, Operand::StaticVariable(allocation_limit)); j(above, gc_required); if ((flags & TAG_OBJECT) != 0) { @@ -1407,14 +1406,13 @@ void MacroAssembler::AllocateInNewSpace( } -void MacroAssembler::AllocateInNewSpace(Register object_size, - Register result, - Register result_end, - Register scratch, - Label* gc_required, - AllocationFlags flags) { +void MacroAssembler::Allocate(Register object_size, + Register result, + Register result_end, + Register scratch, + Label* gc_required, + AllocationFlags flags) { ASSERT((flags & (RESULT_CONTAINS_TOP | SIZE_IN_WORDS)) == 0); - ASSERT((flags & PRETENURE_OLD_POINTER_SPACE) == 0); if (!FLAG_inline_new) { if (emit_debug_code()) { // Trash the registers to simulate an allocation failure. @@ -1436,6 +1434,7 @@ void MacroAssembler::AllocateInNewSpace(Register object_size, // Align the next allocation. Storing the filler map without checking top is // always safe because the limit of the heap is always aligned. if ((flags & DOUBLE_ALIGNMENT) != 0) { + ASSERT((flags & PRETENURE_OLD_POINTER_SPACE) == 0); ASSERT(kPointerAlignment * 2 == kDoubleAlignment); Label aligned; test(result, Immediate(kDoubleAlignmentMask)); @@ -1446,15 +1445,16 @@ void MacroAssembler::AllocateInNewSpace(Register object_size, bind(&aligned); } - // Calculate new top and bail out if new space is exhausted. - ExternalReference new_space_allocation_limit = - ExternalReference::new_space_allocation_limit_address(isolate()); + // Calculate new top and bail out if space is exhausted. + ExternalReference allocation_limit = + AllocationUtils::GetAllocationLimitReference(isolate(), flags); + if (!object_size.is(result_end)) { mov(result_end, object_size); } add(result_end, result); j(carry, gc_required); - cmp(result_end, Operand::StaticVariable(new_space_allocation_limit)); + cmp(result_end, Operand::StaticVariable(allocation_limit)); j(above, gc_required); // Tag result if requested. @@ -1511,15 +1511,15 @@ void MacroAssembler::AllocateTwoByteString(Register result, and_(scratch1, Immediate(~kObjectAlignmentMask)); // Allocate two byte string in new space. - AllocateInNewSpace(SeqTwoByteString::kHeaderSize, - times_1, - scratch1, - REGISTER_VALUE_IS_INT32, - result, - scratch2, - scratch3, - gc_required, - TAG_OBJECT); + Allocate(SeqTwoByteString::kHeaderSize, + times_1, + scratch1, + REGISTER_VALUE_IS_INT32, + result, + scratch2, + scratch3, + gc_required, + TAG_OBJECT); // Set the map, length and hash field. mov(FieldOperand(result, HeapObject::kMapOffset), @@ -1547,15 +1547,15 @@ void MacroAssembler::AllocateAsciiString(Register result, and_(scratch1, Immediate(~kObjectAlignmentMask)); // Allocate ASCII string in new space. - AllocateInNewSpace(SeqOneByteString::kHeaderSize, - times_1, - scratch1, - REGISTER_VALUE_IS_INT32, - result, - scratch2, - scratch3, - gc_required, - TAG_OBJECT); + Allocate(SeqOneByteString::kHeaderSize, + times_1, + scratch1, + REGISTER_VALUE_IS_INT32, + result, + scratch2, + scratch3, + gc_required, + TAG_OBJECT); // Set the map, length and hash field. mov(FieldOperand(result, HeapObject::kMapOffset), diff --git a/src/ia32/macro-assembler-ia32.h b/src/ia32/macro-assembler-ia32.h index 8dd4120..b3dae73 100644 --- a/src/ia32/macro-assembler-ia32.h +++ b/src/ia32/macro-assembler-ia32.h @@ -582,22 +582,22 @@ class MacroAssembler: public Assembler { Label* gc_required, AllocationFlags flags); - void AllocateInNewSpace(int header_size, - ScaleFactor element_size, - Register element_count, - RegisterValueType element_count_type, - Register result, - Register result_end, - Register scratch, - Label* gc_required, - AllocationFlags flags); - - void AllocateInNewSpace(Register object_size, - Register result, - Register result_end, - Register scratch, - Label* gc_required, - AllocationFlags flags); + void Allocate(int header_size, + ScaleFactor element_size, + Register element_count, + RegisterValueType element_count_type, + Register result, + Register result_end, + Register scratch, + Label* gc_required, + AllocationFlags flags); + + void Allocate(Register object_size, + Register result, + Register result_end, + Register scratch, + Label* gc_required, + AllocationFlags flags); // Undo allocation in new space. The object passed and objects allocated after // it will no longer be allocated. Make sure that no pointers are left to the diff --git a/src/x64/builtins-x64.cc b/src/x64/builtins-x64.cc index a49497e..2da3de2 100644 --- a/src/x64/builtins-x64.cc +++ b/src/x64/builtins-x64.cc @@ -220,12 +220,12 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm, __ movzxbq(rdi, FieldOperand(rax, Map::kInstanceSizeOffset)); __ shl(rdi, Immediate(kPointerSizeLog2)); // rdi: size of new object - __ AllocateInNewSpace(rdi, - rbx, - rdi, - no_reg, - &rt_call, - NO_ALLOCATION_FLAGS); + __ Allocate(rdi, + rbx, + rdi, + no_reg, + &rt_call, + NO_ALLOCATION_FLAGS); // Allocated the JSObject, now initialize the fields. // rax: initial map // rbx: JSObject (not HeapObject tagged - the actual address). @@ -287,14 +287,14 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm, // rbx: JSObject // rdi: start of next object (will be start of FixedArray) // rdx: number of elements in properties array - __ AllocateInNewSpace(FixedArray::kHeaderSize, - times_pointer_size, - rdx, - rdi, - rax, - no_reg, - &undo_allocation, - RESULT_CONTAINS_TOP); + __ Allocate(FixedArray::kHeaderSize, + times_pointer_size, + rdx, + rdi, + rax, + no_reg, + &undo_allocation, + RESULT_CONTAINS_TOP); // Initialize the FixedArray. // rbx: JSObject @@ -1212,14 +1212,14 @@ static void AllocateJSArray(MacroAssembler* masm, // requested elements. SmiIndex index = masm->SmiToIndex(kScratchRegister, array_size, kPointerSizeLog2); - __ AllocateInNewSpace(JSArray::kSize + FixedArray::kHeaderSize, - index.scale, - index.reg, - result, - elements_array_end, - scratch, - gc_required, - TAG_OBJECT); + __ Allocate(JSArray::kSize + FixedArray::kHeaderSize, + index.scale, + index.reg, + result, + elements_array_end, + scratch, + gc_required, + TAG_OBJECT); // Allocated the JSArray. Now initialize the fields except for the elements // array. diff --git a/src/x64/code-stubs-x64.cc b/src/x64/code-stubs-x64.cc index 4ff1635..7ba3459 100644 --- a/src/x64/code-stubs-x64.cc +++ b/src/x64/code-stubs-x64.cc @@ -2663,7 +2663,7 @@ void ArgumentsAccessStub::GenerateNewNonStrictFast(MacroAssembler* masm) { __ addq(r8, Immediate(Heap::kArgumentsObjectSize)); // Do the allocation of all three objects in one go. - __ AllocateInNewSpace(r8, rax, rdx, rdi, &runtime, TAG_OBJECT); + __ Allocate(r8, rax, rdx, rdi, &runtime, TAG_OBJECT); // rax = address of new object(s) (tagged) // rcx = argument count (untagged) @@ -2881,7 +2881,7 @@ void ArgumentsAccessStub::GenerateNewStrict(MacroAssembler* masm) { __ addq(rcx, Immediate(Heap::kArgumentsObjectSizeStrict)); // Do the allocation of both objects in one go. - __ AllocateInNewSpace(rcx, rax, rdx, rbx, &runtime, TAG_OBJECT); + __ Allocate(rcx, rax, rdx, rbx, &runtime, TAG_OBJECT); // Get the arguments boilerplate from the current native context. __ movq(rdi, Operand(rsi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX))); @@ -3414,14 +3414,14 @@ void RegExpConstructResultStub::Generate(MacroAssembler* masm) { // Allocate RegExpResult followed by FixedArray with size in rbx. // JSArray: [Map][empty properties][Elements][Length-smi][index][input] // Elements: [Map][Length][..elements..] - __ AllocateInNewSpace(JSRegExpResult::kSize + FixedArray::kHeaderSize, - times_pointer_size, - rbx, // In: Number of elements. - rax, // Out: Start of allocation (tagged). - rcx, // Out: End of allocation. - rdx, // Scratch register - &slowcase, - TAG_OBJECT); + __ Allocate(JSRegExpResult::kSize + FixedArray::kHeaderSize, + times_pointer_size, + rbx, // In: Number of elements. + rax, // Out: Start of allocation (tagged). + rcx, // Out: End of allocation. + rdx, // Scratch register + &slowcase, + TAG_OBJECT); // rax: Start of allocated area, object-tagged. // rbx: Number of array elements as int32. // r8: Number of array elements as smi. diff --git a/src/x64/codegen-x64.cc b/src/x64/codegen-x64.cc index ec66127..6f32f7c 100644 --- a/src/x64/codegen-x64.cc +++ b/src/x64/codegen-x64.cc @@ -347,7 +347,7 @@ void ElementsTransitionGenerator::GenerateSmiToDouble( // Allocate new backing store. __ bind(&new_backing_store); __ lea(rdi, Operand(r9, times_pointer_size, FixedArray::kHeaderSize)); - __ AllocateInNewSpace(rdi, r14, r11, r15, fail, TAG_OBJECT); + __ Allocate(rdi, r14, r11, r15, fail, TAG_OBJECT); // Set backing store's map __ LoadRoot(rdi, Heap::kFixedDoubleArrayMapRootIndex); __ movq(FieldOperand(r14, HeapObject::kMapOffset), rdi); @@ -435,7 +435,7 @@ void ElementsTransitionGenerator::GenerateDoubleToObject( // r8 : source FixedDoubleArray // r9 : number of elements __ lea(rdi, Operand(r9, times_pointer_size, FixedArray::kHeaderSize)); - __ AllocateInNewSpace(rdi, r11, r14, r15, &gc_required, TAG_OBJECT); + __ Allocate(rdi, r11, r14, r15, &gc_required, TAG_OBJECT); // r11: destination FixedArray __ LoadRoot(rdi, Heap::kFixedArrayMapRootIndex); __ movq(FieldOperand(r11, HeapObject::kMapOffset), rdi); diff --git a/src/x64/lithium-codegen-x64.cc b/src/x64/lithium-codegen-x64.cc index 0bb676b..380e60e 100644 --- a/src/x64/lithium-codegen-x64.cc +++ b/src/x64/lithium-codegen-x64.cc @@ -5129,7 +5129,7 @@ void LCodeGen::DoAllocate(LAllocate* instr) { __ Allocate(size, result, temp, no_reg, deferred->entry(), flags); } else { Register size = ToRegister(instr->size()); - __ AllocateInNewSpace(size, result, temp, no_reg, deferred->entry(), flags); + __ Allocate(size, result, temp, no_reg, deferred->entry(), flags); } __ bind(deferred->exit()); diff --git a/src/x64/macro-assembler-x64.cc b/src/x64/macro-assembler-x64.cc index 9ecf66c..6c1c19d 100644 --- a/src/x64/macro-assembler-x64.cc +++ b/src/x64/macro-assembler-x64.cc @@ -3830,16 +3830,15 @@ void MacroAssembler::Allocate(int object_size, } -void MacroAssembler::AllocateInNewSpace(int header_size, - ScaleFactor element_size, - Register element_count, - Register result, - Register result_end, - Register scratch, - Label* gc_required, - AllocationFlags flags) { +void MacroAssembler::Allocate(int header_size, + ScaleFactor element_size, + Register element_count, + Register result, + Register result_end, + Register scratch, + Label* gc_required, + AllocationFlags flags) { ASSERT((flags & SIZE_IN_WORDS) == 0); - ASSERT((flags & PRETENURE_OLD_POINTER_SPACE) == 0); if (!FLAG_inline_new) { if (emit_debug_code()) { // Trash the registers to simulate an allocation failure. @@ -3866,15 +3865,15 @@ void MacroAssembler::AllocateInNewSpace(int header_size, } // Calculate new top and bail out if new space is exhausted. - ExternalReference new_space_allocation_limit = - ExternalReference::new_space_allocation_limit_address(isolate()); + ExternalReference allocation_limit = + AllocationUtils::GetAllocationLimitReference(isolate(), flags); // We assume that element_count*element_size + header_size does not // overflow. lea(result_end, Operand(element_count, element_size, header_size)); addq(result_end, result); j(carry, gc_required); - Operand limit_operand = ExternalOperand(new_space_allocation_limit); + Operand limit_operand = ExternalOperand(allocation_limit); cmpq(result_end, limit_operand); j(above, gc_required); @@ -3889,14 +3888,13 @@ void MacroAssembler::AllocateInNewSpace(int header_size, } -void MacroAssembler::AllocateInNewSpace(Register object_size, - Register result, - Register result_end, - Register scratch, - Label* gc_required, - AllocationFlags flags) { +void MacroAssembler::Allocate(Register object_size, + Register result, + Register result_end, + Register scratch, + Label* gc_required, + AllocationFlags flags) { ASSERT((flags & (RESULT_CONTAINS_TOP | SIZE_IN_WORDS)) == 0); - ASSERT((flags & PRETENURE_OLD_POINTER_SPACE) == 0); if (!FLAG_inline_new) { if (emit_debug_code()) { // Trash the registers to simulate an allocation failure. @@ -3916,14 +3914,14 @@ void MacroAssembler::AllocateInNewSpace(Register object_size, LoadAllocationTopHelper(result, scratch, flags); // Calculate new top and bail out if new space is exhausted. - ExternalReference new_space_allocation_limit = - ExternalReference::new_space_allocation_limit_address(isolate()); + ExternalReference allocation_limit = + AllocationUtils::GetAllocationLimitReference(isolate(), flags); if (!object_size.is(result_end)) { movq(result_end, object_size); } addq(result_end, result); j(carry, gc_required); - Operand limit_operand = ExternalOperand(new_space_allocation_limit); + Operand limit_operand = ExternalOperand(allocation_limit); cmpq(result_end, limit_operand); j(above, gc_required); @@ -3991,14 +3989,14 @@ void MacroAssembler::AllocateTwoByteString(Register result, } // Allocate two byte string in new space. - AllocateInNewSpace(SeqTwoByteString::kHeaderSize, - times_1, - scratch1, - result, - scratch2, - scratch3, - gc_required, - TAG_OBJECT); + Allocate(SeqTwoByteString::kHeaderSize, + times_1, + scratch1, + result, + scratch2, + scratch3, + gc_required, + TAG_OBJECT); // Set the map, length and hash field. LoadRoot(kScratchRegister, Heap::kStringMapRootIndex); @@ -4029,14 +4027,14 @@ void MacroAssembler::AllocateAsciiString(Register result, } // Allocate ASCII string in new space. - AllocateInNewSpace(SeqOneByteString::kHeaderSize, - times_1, - scratch1, - result, - scratch2, - scratch3, - gc_required, - TAG_OBJECT); + Allocate(SeqOneByteString::kHeaderSize, + times_1, + scratch1, + result, + scratch2, + scratch3, + gc_required, + TAG_OBJECT); // Set the map, length and hash field. LoadRoot(kScratchRegister, Heap::kAsciiStringMapRootIndex); diff --git a/src/x64/macro-assembler-x64.h b/src/x64/macro-assembler-x64.h index df52159..3381a5b 100644 --- a/src/x64/macro-assembler-x64.h +++ b/src/x64/macro-assembler-x64.h @@ -1042,21 +1042,21 @@ class MacroAssembler: public Assembler { Label* gc_required, AllocationFlags flags); - void AllocateInNewSpace(int header_size, - ScaleFactor element_size, - Register element_count, - Register result, - Register result_end, - Register scratch, - Label* gc_required, - AllocationFlags flags); + void Allocate(int header_size, + ScaleFactor element_size, + Register element_count, + Register result, + Register result_end, + Register scratch, + Label* gc_required, + AllocationFlags flags); - void AllocateInNewSpace(Register object_size, - Register result, - Register result_end, - Register scratch, - Label* gc_required, - AllocationFlags flags); + void Allocate(Register object_size, + Register result, + Register result_end, + Register scratch, + Label* gc_required, + AllocationFlags flags); // Undo allocation in new space. The object passed and objects allocated after // it will no longer be allocated. Make sure that no pointers are left to the -- 2.7.4