From: yangguo@chromium.org Date: Thu, 1 Sep 2011 15:24:26 +0000 (+0000) Subject: Generated code for substring slices in x64 and arm. X-Git-Tag: upstream/4.7.83~18588 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=1be99a96273938fc4ba30836b7e9792ade7cab6a;p=platform%2Fupstream%2Fv8.git Generated code for substring slices in x64 and arm. Review URL: http://codereview.chromium.org/7795018 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@9111 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- diff --git a/src/arm/code-stubs-arm.cc b/src/arm/code-stubs-arm.cc index 09d2c17..f6b87c3 100644 --- a/src/arm/code-stubs-arm.cc +++ b/src/arm/code-stubs-arm.cc @@ -4894,7 +4894,8 @@ void StringCharCodeAtGenerator::GenerateFast(MacroAssembler* masm) { // Check for 1-byte or 2-byte string. __ bind(&flat_string); - STATIC_ASSERT(kAsciiStringTag != 0); + STATIC_ASSERT((kStringEncodingMask & kAsciiStringTag) != 0); + STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0); __ tst(result_, Operand(kStringEncodingMask)); __ b(ne, &ascii_string); @@ -5468,11 +5469,6 @@ void SubStringStub::Generate(MacroAssembler* masm) { Register to = r6; Register from = r7; - if (FLAG_string_slices) { - __ nop(0); // Jumping as first instruction would crash the code generation. - __ jmp(&runtime); - } - __ Ldrd(to, from, MemOperand(sp, kToOffset)); STATIC_ASSERT(kFromOffset == kToOffset + 4); STATIC_ASSERT(kSmiTag == 0); @@ -5490,64 +5486,79 @@ void SubStringStub::Generate(MacroAssembler* masm) { __ b(mi, &runtime); // Fail if from > to. // Special handling of sub-strings of length 1 and 2. One character strings // are handled in the runtime system (looked up in the single character - // cache). Two character strings are looked for in the symbol cache. + // cache). Two character strings are looked for in the symbol cache in + // generated code. __ cmp(r2, Operand(2)); __ b(lt, &runtime); - // r2: length - // r3: from index (untaged smi) + // r2: result string length + // r3: from index (untagged smi) // r6 (a.k.a. to): to (smi) // r7 (a.k.a. from): from offset (smi) - // Make sure first argument is a sequential (or flat) string. - __ ldr(r5, MemOperand(sp, kStringOffset)); + __ ldr(r0, MemOperand(sp, kStringOffset)); STATIC_ASSERT(kSmiTag == 0); - __ JumpIfSmi(r5, &runtime); - Condition is_string = masm->IsObjectStringType(r5, r1); + __ JumpIfSmi(r0, &runtime); + Condition is_string = masm->IsObjectStringType(r0, r1); __ b(NegateCondition(is_string), &runtime); + // Short-cut for the case of trivial substring. + Label return_r0; + // r0: original string + // r2: result string length + __ ldr(r4, FieldMemOperand(r0, String::kLengthOffset)); + __ cmp(r2, Operand(r4, ASR, 1)); + __ b(eq, &return_r0); + + Label create_slice; + if (FLAG_string_slices) { + __ cmp(r2, Operand(SlicedString::kMinLength)); + __ b(ge, &create_slice); + } + + // r0: original string // r1: instance type - // r2: length + // r2: result string length // r3: from index (untagged smi) - // r5: string // r6 (a.k.a. to): to (smi) // r7 (a.k.a. from): from offset (smi) Label seq_string; __ and_(r4, r1, Operand(kStringRepresentationMask)); STATIC_ASSERT(kSeqStringTag < kConsStringTag); STATIC_ASSERT(kConsStringTag < kExternalStringTag); + STATIC_ASSERT(kConsStringTag < kSlicedStringTag); __ cmp(r4, Operand(kConsStringTag)); - __ b(gt, &runtime); // External strings go to runtime. + __ b(gt, &runtime); // Slices and external strings go to runtime. __ b(lt, &seq_string); // Sequential strings are handled directly. // Cons string. Try to recurse (once) on the first substring. // (This adds a little more generality than necessary to handle flattened // cons strings, but not much). - __ ldr(r5, FieldMemOperand(r5, ConsString::kFirstOffset)); - __ ldr(r4, FieldMemOperand(r5, HeapObject::kMapOffset)); + __ ldr(r0, FieldMemOperand(r0, ConsString::kFirstOffset)); + __ ldr(r4, FieldMemOperand(r0, HeapObject::kMapOffset)); __ ldrb(r1, FieldMemOperand(r4, Map::kInstanceTypeOffset)); __ tst(r1, Operand(kStringRepresentationMask)); STATIC_ASSERT(kSeqStringTag == 0); - __ b(ne, &runtime); // Cons and External strings go to runtime. + __ b(ne, &runtime); // Cons, slices and external strings go to runtime. // Definitly a sequential string. __ bind(&seq_string); - // r1: instance type. - // r2: length - // r3: from index (untaged smi) - // r5: string + // r0: original string + // r1: instance type + // r2: result string length + // r3: from index (untagged smi) // r6 (a.k.a. to): to (smi) // r7 (a.k.a. from): from offset (smi) - __ ldr(r4, FieldMemOperand(r5, String::kLengthOffset)); + __ ldr(r4, FieldMemOperand(r0, String::kLengthOffset)); __ cmp(r4, Operand(to)); __ b(lt, &runtime); // Fail if to > length. to = no_reg; - // r1: instance type. - // r2: result string length. - // r3: from index (untaged smi) - // r5: string. + // r0: original string or left hand side of the original cons string. + // r1: instance type + // r2: result string length + // r3: from index (untagged smi) // r7 (a.k.a. from): from offset (smi) // Check for flat ASCII string. Label non_ascii_flat; @@ -5561,82 +5572,146 @@ void SubStringStub::Generate(MacroAssembler* masm) { // Sub string of length 2 requested. // Get the two characters forming the sub string. - __ add(r5, r5, Operand(r3)); - __ ldrb(r3, FieldMemOperand(r5, SeqAsciiString::kHeaderSize)); - __ ldrb(r4, FieldMemOperand(r5, SeqAsciiString::kHeaderSize + 1)); + __ add(r0, r0, Operand(r3)); + __ ldrb(r3, FieldMemOperand(r0, SeqAsciiString::kHeaderSize)); + __ ldrb(r4, FieldMemOperand(r0, SeqAsciiString::kHeaderSize + 1)); // Try to lookup two character string in symbol table. Label make_two_character_string; StringHelper::GenerateTwoCharacterSymbolTableProbe( masm, r3, r4, r1, r5, r6, r7, r9, &make_two_character_string); Counters* counters = masm->isolate()->counters(); - __ IncrementCounter(counters->sub_string_native(), 1, r3, r4); - __ add(sp, sp, Operand(3 * kPointerSize)); - __ Ret(); + __ jmp(&return_r0); // r2: result string length. // r3: two characters combined into halfword in little endian byte order. __ bind(&make_two_character_string); __ AllocateAsciiString(r0, r2, r4, r5, r9, &runtime); __ strh(r3, FieldMemOperand(r0, SeqAsciiString::kHeaderSize)); - __ IncrementCounter(counters->sub_string_native(), 1, r3, r4); - __ add(sp, sp, Operand(3 * kPointerSize)); - __ Ret(); + __ jmp(&return_r0); __ bind(&result_longer_than_two); + // Locate 'from' character of string. + __ add(r5, r0, Operand(SeqAsciiString::kHeaderSize - kHeapObjectTag)); + __ add(r5, r5, Operand(from, ASR, 1)); + // Allocate the result. __ AllocateAsciiString(r0, r2, r3, r4, r1, &runtime); - // r0: result string. - // r2: result string length. - // r5: string. + // r0: result string + // r2: result string length + // r5: first character of substring to copy // r7 (a.k.a. from): from offset (smi) // Locate first character of result. __ add(r1, r0, Operand(SeqAsciiString::kHeaderSize - kHeapObjectTag)); - // Locate 'from' character of string. - __ add(r5, r5, Operand(SeqAsciiString::kHeaderSize - kHeapObjectTag)); - __ add(r5, r5, Operand(from, ASR, 1)); - // r0: result string. - // r1: first character of result string. - // r2: result string length. - // r5: first character of sub string to copy. + // r0: result string + // r1: first character of result string + // r2: result string length + // r5: first character of substring to copy STATIC_ASSERT((SeqAsciiString::kHeaderSize & kObjectAlignmentMask) == 0); StringHelper::GenerateCopyCharactersLong(masm, r1, r5, r2, r3, r4, r6, r7, r9, COPY_ASCII | DEST_ALWAYS_ALIGNED); - __ IncrementCounter(counters->sub_string_native(), 1, r3, r4); - __ add(sp, sp, Operand(3 * kPointerSize)); - __ Ret(); + __ jmp(&return_r0); __ bind(&non_ascii_flat); - // r2: result string length. - // r5: string. + // r0: original string + // r2: result string length // r7 (a.k.a. from): from offset (smi) // Check for flat two byte string. + // Locate 'from' character of string. + __ add(r5, r0, Operand(SeqTwoByteString::kHeaderSize - kHeapObjectTag)); + // As "from" is a smi it is 2 times the value which matches the size of a two + // byte character. + STATIC_ASSERT(kSmiTagSize == 1 && kSmiTag == 0); + __ add(r5, r5, Operand(from)); + // Allocate the result. __ AllocateTwoByteString(r0, r2, r1, r3, r4, &runtime); - // r0: result string. - // r2: result string length. - // r5: string. + // r0: result string + // r2: result string length + // r5: first character of substring to copy // Locate first character of result. __ add(r1, r0, Operand(SeqTwoByteString::kHeaderSize - kHeapObjectTag)); - // Locate 'from' character of string. - __ add(r5, r5, Operand(SeqTwoByteString::kHeaderSize - kHeapObjectTag)); - // As "from" is a smi it is 2 times the value which matches the size of a two - // byte character. - __ add(r5, r5, Operand(from)); + from = no_reg; // r0: result string. // r1: first character of result. // r2: result length. - // r5: first character of string to copy. + // r5: first character of substring to copy. STATIC_ASSERT((SeqTwoByteString::kHeaderSize & kObjectAlignmentMask) == 0); StringHelper::GenerateCopyCharactersLong( masm, r1, r5, r2, r3, r4, r6, r7, r9, DEST_ALWAYS_ALIGNED); + __ jmp(&return_r0); + + if (FLAG_string_slices) { + __ bind(&create_slice); + // r0: original string + // r1: instance type + // r2: length + // r3: from index (untagged smi) + // r6 (a.k.a. to): to (smi) + // r7 (a.k.a. from): from offset (smi) + Label allocate_slice, sliced_string, seq_string; + STATIC_ASSERT(kSeqStringTag == 0); + __ tst(r1, Operand(kStringRepresentationMask)); + __ b(eq, &seq_string); + STATIC_ASSERT(kIsIndirectStringMask == (kSlicedStringTag & kConsStringTag)); + STATIC_ASSERT(kIsIndirectStringMask != 0); + __ tst(r1, Operand(kIsIndirectStringMask)); + // External string. Jump to runtime. + __ b(eq, &runtime); + + __ tst(r1, Operand(kSlicedNotConsMask)); + __ b(ne, &sliced_string); + // Cons string. Check whether it is flat, then fetch first part. + __ ldr(r5, FieldMemOperand(r0, ConsString::kSecondOffset)); + __ LoadRoot(r9, Heap::kEmptyStringRootIndex); + __ cmp(r5, r9); + __ b(ne, &runtime); + __ ldr(r5, FieldMemOperand(r0, ConsString::kFirstOffset)); + __ jmp(&allocate_slice); + + __ bind(&sliced_string); + // Sliced string. Fetch parent and correct start index by offset. + __ ldr(r5, FieldMemOperand(r0, SlicedString::kOffsetOffset)); + __ add(r7, r7, r5); + __ ldr(r5, FieldMemOperand(r0, SlicedString::kParentOffset)); + __ jmp(&allocate_slice); + + __ bind(&seq_string); + // Sequential string. Just move string to the right register. + __ mov(r5, r0); + + __ bind(&allocate_slice); + // r1: instance type of original string + // r2: length + // r5: underlying subject string + // r7 (a.k.a. from): from offset (smi) + // Allocate new sliced string. At this point we do not reload the instance + // type including the string encoding because we simply rely on the info + // provided by the original string. It does not matter if the original + // string's encoding is wrong because we always have to recheck encoding of + // the newly created string's parent anyways due to externalized strings. + Label two_byte_slice, set_slice_header; + STATIC_ASSERT((kStringEncodingMask & kAsciiStringTag) != 0); + STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0); + __ tst(r1, Operand(kStringEncodingMask)); + __ b(eq, &two_byte_slice); + __ AllocateAsciiSlicedString(r0, r2, r3, r4, &runtime); + __ jmp(&set_slice_header); + __ bind(&two_byte_slice); + __ AllocateTwoByteSlicedString(r0, r2, r3, r4, &runtime); + __ bind(&set_slice_header); + __ str(r7, FieldMemOperand(r0, SlicedString::kOffsetOffset)); + __ str(r5, FieldMemOperand(r0, SlicedString::kParentOffset)); + } + + __ bind(&return_r0); __ IncrementCounter(counters->sub_string_native(), 1, r3, r4); __ add(sp, sp, Operand(3 * kPointerSize)); __ Ret(); diff --git a/src/arm/lithium-codegen-arm.cc b/src/arm/lithium-codegen-arm.cc index 976576b..03ea929 100644 --- a/src/arm/lithium-codegen-arm.cc +++ b/src/arm/lithium-codegen-arm.cc @@ -3509,7 +3509,8 @@ void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) { // Dispatch on the encoding: ASCII or two-byte. Label ascii_string; - STATIC_ASSERT(kAsciiStringTag != 0); + STATIC_ASSERT((kStringEncodingMask & kAsciiStringTag) != 0); + STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0); __ tst(result, Operand(kStringEncodingMask)); __ b(ne, &ascii_string); diff --git a/src/arm/macro-assembler-arm.cc b/src/arm/macro-assembler-arm.cc index 88477bb..613a1f6 100644 --- a/src/arm/macro-assembler-arm.cc +++ b/src/arm/macro-assembler-arm.cc @@ -1725,6 +1725,46 @@ void MacroAssembler::AllocateAsciiConsString(Register result, } +void MacroAssembler::AllocateTwoByteSlicedString(Register result, + Register length, + Register scratch1, + Register scratch2, + Label* gc_required) { + AllocateInNewSpace(SlicedString::kSize, + result, + scratch1, + scratch2, + gc_required, + TAG_OBJECT); + + InitializeNewString(result, + length, + Heap::kSlicedStringMapRootIndex, + scratch1, + scratch2); +} + + +void MacroAssembler::AllocateAsciiSlicedString(Register result, + Register length, + Register scratch1, + Register scratch2, + Label* gc_required) { + AllocateInNewSpace(SlicedString::kSize, + result, + scratch1, + scratch2, + gc_required, + TAG_OBJECT); + + InitializeNewString(result, + length, + Heap::kSlicedAsciiStringMapRootIndex, + scratch1, + scratch2); +} + + void MacroAssembler::CompareObjectType(Register object, Register map, Register type_reg, diff --git a/src/arm/macro-assembler-arm.h b/src/arm/macro-assembler-arm.h index 9c653ad..9d66359 100644 --- a/src/arm/macro-assembler-arm.h +++ b/src/arm/macro-assembler-arm.h @@ -532,6 +532,16 @@ class MacroAssembler: public Assembler { Register scratch1, Register scratch2, Label* gc_required); + void AllocateTwoByteSlicedString(Register result, + Register length, + Register scratch1, + Register scratch2, + Label* gc_required); + void AllocateAsciiSlicedString(Register result, + Register length, + Register scratch1, + Register scratch2, + Label* gc_required); // Allocates a heap number or jumps to the gc_required label if the young // space is full and a scavenge is needed. All registers are clobbered also diff --git a/src/ia32/code-stubs-ia32.cc b/src/ia32/code-stubs-ia32.cc index 85e74b8..f3eb09f 100644 --- a/src/ia32/code-stubs-ia32.cc +++ b/src/ia32/code-stubs-ia32.cc @@ -4907,7 +4907,8 @@ void StringCharCodeAtGenerator::GenerateFast(MacroAssembler* masm) { // Check for 1-byte or 2-byte string. __ bind(&flat_string); - STATIC_ASSERT(kAsciiStringTag != 0); + STATIC_ASSERT((kStringEncodingMask & kAsciiStringTag) != 0); + STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0); __ test(result_, Immediate(kStringEncodingMask)); __ j(not_zero, &ascii_string, Label::kNear); @@ -5178,8 +5179,9 @@ void StringAddStub::Generate(MacroAssembler* masm) { __ mov(edi, FieldOperand(edx, HeapObject::kMapOffset)); __ movzx_b(edi, FieldOperand(edi, Map::kInstanceTypeOffset)); __ and_(ecx, Operand(edi)); - STATIC_ASSERT(kStringEncodingMask == kAsciiStringTag); - __ test(ecx, Immediate(kAsciiStringTag)); + STATIC_ASSERT((kStringEncodingMask & kAsciiStringTag) != 0); + STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0); + __ test(ecx, Immediate(kStringEncodingMask)); __ j(zero, &non_ascii); __ bind(&ascii_data); // Allocate an acsii cons string. @@ -5210,7 +5212,7 @@ void StringAddStub::Generate(MacroAssembler* masm) { __ cmp(edi, kAsciiStringTag | kAsciiDataHintTag); __ j(equal, &ascii_data); // Allocate a two byte cons string. - __ AllocateConsString(ecx, edi, no_reg, &string_add_runtime); + __ AllocateTwoByteConsString(ecx, edi, no_reg, &string_add_runtime); __ jmp(&allocated); // Handle creating a flat result. First check that both strings are not @@ -5236,12 +5238,13 @@ void StringAddStub::Generate(MacroAssembler* masm) { // ebx: length of resulting flat string as a smi // edx: second string Label non_ascii_string_add_flat_result; - STATIC_ASSERT(kStringEncodingMask == kAsciiStringTag); + STATIC_ASSERT((kStringEncodingMask & kAsciiStringTag) != 0); + STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0); __ mov(ecx, FieldOperand(eax, HeapObject::kMapOffset)); - __ test_b(FieldOperand(ecx, Map::kInstanceTypeOffset), kAsciiStringTag); + __ test_b(FieldOperand(ecx, Map::kInstanceTypeOffset), kStringEncodingMask); __ j(zero, &non_ascii_string_add_flat_result); __ mov(ecx, FieldOperand(edx, HeapObject::kMapOffset)); - __ test_b(FieldOperand(ecx, Map::kInstanceTypeOffset), kAsciiStringTag); + __ test_b(FieldOperand(ecx, Map::kInstanceTypeOffset), kStringEncodingMask); __ j(zero, &string_add_runtime); // Both strings are ascii strings. As they are short they are both flat. @@ -5281,7 +5284,7 @@ void StringAddStub::Generate(MacroAssembler* masm) { // edx: second string __ bind(&non_ascii_string_add_flat_result); __ mov(ecx, FieldOperand(edx, HeapObject::kMapOffset)); - __ test_b(FieldOperand(ecx, Map::kInstanceTypeOffset), kAsciiStringTag); + __ test_b(FieldOperand(ecx, Map::kInstanceTypeOffset), kStringEncodingMask); __ j(not_zero, &string_add_runtime); // Both strings are two byte strings. As they are short they are both // flat. @@ -5759,13 +5762,14 @@ void SubStringStub::Generate(MacroAssembler* masm) { // string's encoding is wrong because we always have to recheck encoding of // the newly created string's parent anyways due to externalized strings. Label two_byte_slice, set_slice_header; - STATIC_ASSERT(kAsciiStringTag != 0); - __ test(ebx, Immediate(kAsciiStringTag)); + STATIC_ASSERT((kStringEncodingMask & kAsciiStringTag) != 0); + STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0); + __ test(ebx, Immediate(kStringEncodingMask)); __ j(zero, &two_byte_slice, Label::kNear); __ AllocateAsciiSlicedString(eax, ebx, no_reg, &runtime); __ jmp(&set_slice_header, Label::kNear); __ bind(&two_byte_slice); - __ AllocateSlicedString(eax, ebx, no_reg, &runtime); + __ AllocateTwoByteSlicedString(eax, ebx, no_reg, &runtime); __ bind(&set_slice_header); __ mov(FieldOperand(eax, SlicedString::kOffsetOffset), edx); __ SmiTag(ecx); diff --git a/src/ia32/lithium-codegen-ia32.cc b/src/ia32/lithium-codegen-ia32.cc index 32e3074..7136105 100644 --- a/src/ia32/lithium-codegen-ia32.cc +++ b/src/ia32/lithium-codegen-ia32.cc @@ -3269,7 +3269,8 @@ void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) { // Dispatch on the encoding: ASCII or two-byte. Label ascii_string; - STATIC_ASSERT(kAsciiStringTag != 0); + STATIC_ASSERT((kStringEncodingMask & kAsciiStringTag) != 0); + STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0); __ test(result, Immediate(kStringEncodingMask)); __ j(not_zero, &ascii_string, Label::kNear); diff --git a/src/ia32/macro-assembler-ia32.cc b/src/ia32/macro-assembler-ia32.cc index dff174c..6d3ce2b 100644 --- a/src/ia32/macro-assembler-ia32.cc +++ b/src/ia32/macro-assembler-ia32.cc @@ -1172,7 +1172,7 @@ void MacroAssembler::AllocateAsciiString(Register result, } -void MacroAssembler::AllocateConsString(Register result, +void MacroAssembler::AllocateTwoByteConsString(Register result, Register scratch1, Register scratch2, Label* gc_required) { @@ -1208,7 +1208,7 @@ void MacroAssembler::AllocateAsciiConsString(Register result, } -void MacroAssembler::AllocateSlicedString(Register result, +void MacroAssembler::AllocateTwoByteSlicedString(Register result, Register scratch1, Register scratch2, Label* gc_required) { diff --git a/src/ia32/macro-assembler-ia32.h b/src/ia32/macro-assembler-ia32.h index de9361d..1906644 100644 --- a/src/ia32/macro-assembler-ia32.h +++ b/src/ia32/macro-assembler-ia32.h @@ -437,7 +437,7 @@ class MacroAssembler: public Assembler { // Allocate a raw cons string object. Only the map field of the result is // initialized. - void AllocateConsString(Register result, + void AllocateTwoByteConsString(Register result, Register scratch1, Register scratch2, Label* gc_required); @@ -448,7 +448,7 @@ class MacroAssembler: public Assembler { // Allocate a raw sliced string object. Only the map field of the result is // initialized. - void AllocateSlicedString(Register result, + void AllocateTwoByteSlicedString(Register result, Register scratch1, Register scratch2, Label* gc_required); diff --git a/src/mips/code-stubs-mips.cc b/src/mips/code-stubs-mips.cc index 7c2a146..7ca78f6 100644 --- a/src/mips/code-stubs-mips.cc +++ b/src/mips/code-stubs-mips.cc @@ -5079,7 +5079,8 @@ void StringCharCodeAtGenerator::GenerateFast(MacroAssembler* masm) { // Check for 1-byte or 2-byte string. __ bind(&flat_string); - STATIC_ASSERT(kAsciiStringTag != 0); + STATIC_ASSERT((kStringEncodingMask & kAsciiStringTag) != 0); + STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0); __ And(t0, result_, Operand(kStringEncodingMask)); __ Branch(&ascii_string, ne, t0, Operand(zero_reg)); diff --git a/src/x64/code-stubs-x64.cc b/src/x64/code-stubs-x64.cc index 9237a0a..2ae4d9f 100644 --- a/src/x64/code-stubs-x64.cc +++ b/src/x64/code-stubs-x64.cc @@ -3938,7 +3938,8 @@ void StringCharCodeAtGenerator::GenerateFast(MacroAssembler* masm) { // Check for 1-byte or 2-byte string. __ bind(&flat_string); - STATIC_ASSERT(kAsciiStringTag != 0); + STATIC_ASSERT((kStringEncodingMask & kAsciiStringTag) != 0); + STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0); __ testb(result_, Immediate(kStringEncodingMask)); __ j(not_zero, &ascii_string); @@ -4195,8 +4196,9 @@ void StringAddStub::Generate(MacroAssembler* masm) { Label non_ascii, allocated, ascii_data; __ movl(rcx, r8); __ and_(rcx, r9); - STATIC_ASSERT(kStringEncodingMask == kAsciiStringTag); - __ testl(rcx, Immediate(kAsciiStringTag)); + STATIC_ASSERT((kStringEncodingMask & kAsciiStringTag) != 0); + STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0); + __ testl(rcx, Immediate(kStringEncodingMask)); __ j(zero, &non_ascii); __ bind(&ascii_data); // Allocate an acsii cons string. @@ -4225,7 +4227,7 @@ void StringAddStub::Generate(MacroAssembler* masm) { __ cmpb(r8, Immediate(kAsciiStringTag | kAsciiDataHintTag)); __ j(equal, &ascii_data); // Allocate a two byte cons string. - __ AllocateConsString(rcx, rdi, no_reg, &string_add_runtime); + __ AllocateTwoByteConsString(rcx, rdi, no_reg, &string_add_runtime); __ jmp(&allocated); // Handle creating a flat result. First check that both strings are not @@ -4254,10 +4256,11 @@ void StringAddStub::Generate(MacroAssembler* masm) { // r8: instance type of first string // r9: instance type of second string Label non_ascii_string_add_flat_result; - STATIC_ASSERT(kStringEncodingMask == kAsciiStringTag); - __ testl(r8, Immediate(kAsciiStringTag)); + STATIC_ASSERT((kStringEncodingMask & kAsciiStringTag) != 0); + STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0); + __ testl(r8, Immediate(kStringEncodingMask)); __ j(zero, &non_ascii_string_add_flat_result); - __ testl(r9, Immediate(kAsciiStringTag)); + __ testl(r9, Immediate(kStringEncodingMask)); __ j(zero, &string_add_runtime); __ bind(&make_flat_ascii_string); @@ -4295,7 +4298,9 @@ void StringAddStub::Generate(MacroAssembler* masm) { // r8: instance type of first string // r9: instance type of first string __ bind(&non_ascii_string_add_flat_result); - __ and_(r9, Immediate(kAsciiStringTag)); + STATIC_ASSERT((kStringEncodingMask & kAsciiStringTag) != 0); + STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0); + __ and_(r9, Immediate(kStringEncodingMask)); __ j(not_zero, &string_add_runtime); // Both strings are two byte strings. As they are short they are both // flat. @@ -4639,9 +4644,6 @@ void StringHelper::GenerateHashGetHash(MacroAssembler* masm, void SubStringStub::Generate(MacroAssembler* masm) { Label runtime; - if (FLAG_string_slices) { - __ jmp(&runtime); - } // Stack frame on entry. // rsp[0]: return address // rsp[8]: to @@ -4707,7 +4709,82 @@ void SubStringStub::Generate(MacroAssembler* masm) { __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset)); __ Set(rcx, 2); - __ bind(&result_longer_than_two); + if (FLAG_string_slices) { + Label copy_routine; + // If coming from the make_two_character_string path, the string + // is too short to be sliced anyways. + STATIC_ASSERT(2 < SlicedString::kMinLength); + __ jmp(©_routine); + __ bind(&result_longer_than_two); + + // rax: string + // rbx: instance type + // rcx: sub string length + // rdx: from index (smi) + Label allocate_slice, sliced_string, seq_string; + __ cmpq(rcx, Immediate(SlicedString::kMinLength)); + // Short slice. Copy instead of slicing. + __ j(less, ©_routine); + STATIC_ASSERT(kSeqStringTag == 0); + __ testb(rbx, Immediate(kStringRepresentationMask)); + __ j(zero, &seq_string, Label::kNear); + STATIC_ASSERT(kIsIndirectStringMask == (kSlicedStringTag & kConsStringTag)); + STATIC_ASSERT(kIsIndirectStringMask != 0); + __ testb(rbx, Immediate(kIsIndirectStringMask)); + // External string. Jump to runtime. + __ j(zero, &runtime); + + __ testb(rbx, Immediate(kSlicedNotConsMask)); + __ j(not_zero, &sliced_string, Label::kNear); + // Cons string. Check whether it is flat, then fetch first part. + __ CompareRoot(FieldOperand(rax, ConsString::kSecondOffset), + Heap::kEmptyStringRootIndex); + __ j(not_equal, &runtime); + __ movq(rdi, FieldOperand(rax, ConsString::kFirstOffset)); + __ jmp(&allocate_slice, Label::kNear); + + __ bind(&sliced_string); + // Sliced string. Fetch parent and correct start index by offset. + __ addq(rdx, FieldOperand(rax, SlicedString::kOffsetOffset)); + __ movq(rdi, FieldOperand(rax, SlicedString::kParentOffset)); + __ jmp(&allocate_slice, Label::kNear); + + __ bind(&seq_string); + // Sequential string. Just move string to the right register. + __ movq(rdi, rax); + + __ bind(&allocate_slice); + // edi: underlying subject string + // ebx: instance type of original subject string + // edx: offset + // ecx: length + // Allocate new sliced string. At this point we do not reload the instance + // type including the string encoding because we simply rely on the info + // provided by the original string. It does not matter if the original + // string's encoding is wrong because we always have to recheck encoding of + // the newly created string's parent anyways due to externalized strings. + Label two_byte_slice, set_slice_header; + STATIC_ASSERT((kStringEncodingMask & kAsciiStringTag) != 0); + STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0); + __ testb(rbx, Immediate(kStringEncodingMask)); + __ j(zero, &two_byte_slice, Label::kNear); + __ AllocateAsciiSlicedString(rax, rbx, no_reg, &runtime); + __ jmp(&set_slice_header, Label::kNear); + __ bind(&two_byte_slice); + __ AllocateTwoByteSlicedString(rax, rbx, no_reg, &runtime); + __ bind(&set_slice_header); + __ movq(FieldOperand(rax, SlicedString::kOffsetOffset), rdx); + __ Integer32ToSmi(rcx, rcx); + __ movq(FieldOperand(rax, SlicedString::kLengthOffset), rcx); + __ movq(FieldOperand(rax, SlicedString::kParentOffset), rdi); + __ movq(FieldOperand(rax, SlicedString::kHashFieldOffset), + Immediate(String::kEmptyHashField)); + __ jmp(&return_rax); + + __ bind(©_routine); + } else { + __ bind(&result_longer_than_two); + } // rax: string // rbx: instance type diff --git a/src/x64/lithium-codegen-x64.cc b/src/x64/lithium-codegen-x64.cc index c182413..25863ed 100644 --- a/src/x64/lithium-codegen-x64.cc +++ b/src/x64/lithium-codegen-x64.cc @@ -3251,7 +3251,8 @@ void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) { // Dispatch on the encoding: ASCII or two-byte. Label ascii_string; - STATIC_ASSERT(kAsciiStringTag != 0); + STATIC_ASSERT((kStringEncodingMask & kAsciiStringTag) != 0); + STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0); __ testb(result, Immediate(kStringEncodingMask)); __ j(not_zero, &ascii_string, Label::kNear); diff --git a/src/x64/macro-assembler-x64.cc b/src/x64/macro-assembler-x64.cc index b51d531..2ee506d 100644 --- a/src/x64/macro-assembler-x64.cc +++ b/src/x64/macro-assembler-x64.cc @@ -3623,7 +3623,7 @@ void MacroAssembler::AllocateAsciiString(Register result, } -void MacroAssembler::AllocateConsString(Register result, +void MacroAssembler::AllocateTwoByteConsString(Register result, Register scratch1, Register scratch2, Label* gc_required) { @@ -3659,6 +3659,42 @@ void MacroAssembler::AllocateAsciiConsString(Register result, } +void MacroAssembler::AllocateTwoByteSlicedString(Register result, + Register scratch1, + Register scratch2, + Label* gc_required) { + // Allocate heap number in new space. + AllocateInNewSpace(SlicedString::kSize, + result, + scratch1, + scratch2, + gc_required, + TAG_OBJECT); + + // Set the map. The other fields are left uninitialized. + LoadRoot(kScratchRegister, Heap::kSlicedStringMapRootIndex); + movq(FieldOperand(result, HeapObject::kMapOffset), kScratchRegister); +} + + +void MacroAssembler::AllocateAsciiSlicedString(Register result, + Register scratch1, + Register scratch2, + Label* gc_required) { + // Allocate heap number in new space. + AllocateInNewSpace(SlicedString::kSize, + result, + scratch1, + scratch2, + gc_required, + TAG_OBJECT); + + // Set the map. The other fields are left uninitialized. + LoadRoot(kScratchRegister, Heap::kSlicedAsciiStringMapRootIndex); + movq(FieldOperand(result, HeapObject::kMapOffset), kScratchRegister); +} + + // Copy memory, byte-by-byte, from source to destination. Not optimized for // long or aligned copies. The contents of scratch and length are destroyed. // Destination is incremented by length, source, length and scratch are diff --git a/src/x64/macro-assembler-x64.h b/src/x64/macro-assembler-x64.h index 47ce01b..e7eb104 100644 --- a/src/x64/macro-assembler-x64.h +++ b/src/x64/macro-assembler-x64.h @@ -921,7 +921,7 @@ class MacroAssembler: public Assembler { // Allocate a raw cons string object. Only the map field of the result is // initialized. - void AllocateConsString(Register result, + void AllocateTwoByteConsString(Register result, Register scratch1, Register scratch2, Label* gc_required); @@ -930,6 +930,17 @@ class MacroAssembler: public Assembler { Register scratch2, Label* gc_required); + // Allocate a raw sliced string object. Only the map field of the result is + // initialized. + void AllocateTwoByteSlicedString(Register result, + Register scratch1, + Register scratch2, + Label* gc_required); + void AllocateAsciiSlicedString(Register result, + Register scratch1, + Register scratch2, + Label* gc_required); + // --------------------------------------------------------------------------- // Support functions. diff --git a/test/cctest/test-strings.cc b/test/cctest/test-strings.cc index 17020a3..55c2141 100644 --- a/test/cctest/test-strings.cc +++ b/test/cctest/test-strings.cc @@ -529,3 +529,32 @@ TEST(TrivialSlice) { CHECK(string->IsSlicedString()); CHECK_EQ("bcdefghijklmnopqrstuvwxy", *(string->ToCString())); } + + +TEST(SliceFromSlice) { + // This tests whether a slice that contains the entire parent string + // actually creates a new string (it should not). + FLAG_string_slices = true; + InitializeVM(); + HandleScope scope; + v8::Local result; + Handle string; + const char* init = "var str = 'abcdefghijklmnopqrstuvwxyz';"; + const char* slice = "var slice = str.slice(1,-1); slice"; + const char* slice_from_slice = "slice.slice(1,-1);"; + + CompileRun(init); + result = CompileRun(slice); + CHECK(result->IsString()); + string = v8::Utils::OpenHandle(v8::String::Cast(*result)); + CHECK(string->IsSlicedString()); + CHECK(SlicedString::cast(*string)->parent()->IsSeqString()); + CHECK_EQ("bcdefghijklmnopqrstuvwxy", *(string->ToCString())); + + result = CompileRun(slice_from_slice); + CHECK(result->IsString()); + string = v8::Utils::OpenHandle(v8::String::Cast(*result)); + CHECK(string->IsSlicedString()); + CHECK(SlicedString::cast(*string)->parent()->IsSeqString()); + CHECK_EQ("cdefghijklmnopqrstuvwx", *(string->ToCString())); +}