src/x64/codegen-x64.cc - Issue 1857001: Revert "Changing string length field type from int to SMI."

Unified Diff: src/x64/codegen-x64.cc

Issue 1857001: Revert "Changing string length field type from int to SMI." (Closed)

Patch Set: Created 10 years, 8 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: src/x64/codegen-x64.cc

diff --git a/src/x64/codegen-x64.cc b/src/x64/codegen-x64.cc

index 1bf76988e4b46b5bde3a1d56ee4050741626b719..5036637a4d8e239e09877ed4dc295ea55b2eb457 100644

--- a/src/x64/codegen-x64.cc

+++ b/src/x64/codegen-x64.cc

@@ -3922,6 +3922,9 @@ void CodeGenerator::GenerateFastCharCodeAt(ZoneList<Expression*>* args) {

// If the index is negative or non-smi trigger the slow case.

__ JumpIfNotPositiveSmi(index.reg(), &slow_case);

+ // Untag the index.

+ __ SmiToInteger32(index.reg(), index.reg());

__ bind(&try_again_with_new_string);

// Fetch the instance type of the receiver into rcx.

__ movq(rcx, FieldOperand(object.reg(), HeapObject::kMapOffset));

@@ -3931,7 +3934,7 @@ void CodeGenerator::GenerateFastCharCodeAt(ZoneList<Expression*>* args) {

__ j(not_zero, &slow_case);

// Check for index out of range.

- __ SmiCompare(index.reg(), FieldOperand(object.reg(), String::kLengthOffset));

+ __ cmpl(index.reg(), FieldOperand(object.reg(), String::kLengthOffset));

__ j(greater_equal, &slow_case);

// Reload the instance type (into the temp register this time)..

__ movq(temp.reg(), FieldOperand(object.reg(), HeapObject::kMapOffset));

@@ -3943,10 +3946,6 @@ void CodeGenerator::GenerateFastCharCodeAt(ZoneList<Expression*>* args) {

__ j(not_zero, &not_a_flat_string);

// Check for 1-byte or 2-byte string.

ASSERT_EQ(0, kTwoByteStringTag);

- // Untag the index.

- __ SmiToInteger32(index.reg(), index.reg());

__ testb(temp.reg(), Immediate(kStringEncodingMask));

__ j(not_zero, &ascii_string);

@@ -5617,8 +5616,8 @@ void CodeGenerator::Comparison(AstNode* node,

// Test string equality and comparison.

if (cc == equal) {

Label comparison_done;

- __ SmiCompare(FieldOperand(left_side.reg(), String::kLengthOffset),

- Smi::FromInt(1));

+ __ cmpl(FieldOperand(left_side.reg(), String::kLengthOffset),

+ Immediate(1));

__ j(not_equal, &comparison_done);

uint8_t char_value =

static_cast<uint8_t>(String::cast(*right_val)->Get(0));

@@ -5626,9 +5625,9 @@ void CodeGenerator::Comparison(AstNode* node,

Immediate(char_value));

__ bind(&comparison_done);

} else {

- __ movq(temp2.reg(),

+ __ movl(temp2.reg(),

FieldOperand(left_side.reg(), String::kLengthOffset));

- __ SmiSubConstant(temp2.reg(), temp2.reg(), Smi::FromInt(1));

+ __ subl(temp2.reg(), Immediate(1));

Label comparison;

// If the length is 0 then the subtraction gave -1 which compares less

// than any character.

@@ -5646,8 +5645,8 @@ void CodeGenerator::Comparison(AstNode* node,

__ j(not_equal, &characters_were_different);

// If the first character is the same then the long string sorts after

// the short one.

- __ SmiCompare(FieldOperand(left_side.reg(), String::kLengthOffset),

- Smi::FromInt(1));

+ __ cmpl(FieldOperand(left_side.reg(), String::kLengthOffset),

+ Immediate(1));

__ bind(&characters_were_different);

}

temp2.Unuse();

@@ -7096,8 +7095,8 @@ void ToBooleanStub::Generate(MacroAssembler* masm) {

// String value => false iff empty.

__ cmpq(rcx, Immediate(FIRST_NONSTRING_TYPE));

__ j(above_equal, &not_string);

- __ movq(rdx, FieldOperand(rax, String::kLengthOffset));

- __ testq(rdx, rdx);

+ __ movl(rdx, FieldOperand(rax, String::kLengthOffset));

+ __ testl(rdx, rdx);

__ j(zero, &false_result);

__ jmp(&true_result);

@@ -7497,17 +7496,17 @@ void RegExpExecStub::Generate(MacroAssembler* masm) {

Condition is_string = masm->IsObjectStringType(rax, rbx, rbx);

__ j(NegateCondition(is_string), &runtime);

// Get the length of the string to rbx.

- __ movq(rbx, FieldOperand(rax, String::kLengthOffset));

+ __ movl(rbx, FieldOperand(rax, String::kLengthOffset));

- // rbx: Length of subject string as smi

+ // rbx: Length of subject string

// rcx: RegExp data (FixedArray)

// rdx: Number of capture registers

// Check that the third argument is a positive smi less than the string

// length. A negative value will be greater (unsigned comparison).

__ movq(rax, Operand(rsp, kPreviousIndexOffset));

- __ JumpIfNotSmi(rax, &runtime);

- __ SmiCompare(rax, rbx);

- __ j(above_equal, &runtime);

+ __ SmiToInteger32(rax, rax);

+ __ cmpl(rax, rbx);

+ __ j(above, &runtime);

// rcx: RegExp data (FixedArray)

// rdx: Number of capture registers

@@ -7660,14 +7659,12 @@ void RegExpExecStub::Generate(MacroAssembler* masm) {

// Argument 3: Start of string data

Label setup_two_byte, setup_rest;

__ testb(rdi, rdi);

- __ movq(rdi, FieldOperand(rax, String::kLengthOffset));

+ __ movl(rdi, FieldOperand(rax, String::kLengthOffset));

__ j(zero, &setup_two_byte);

- __ SmiToInteger32(rdi, rdi);

__ lea(arg4, FieldOperand(rax, rdi, times_1, SeqAsciiString::kHeaderSize));

__ lea(arg3, FieldOperand(rax, rbx, times_1, SeqAsciiString::kHeaderSize));

__ jmp(&setup_rest);

__ bind(&setup_two_byte);

- __ SmiToInteger32(rdi, rdi);

__ lea(arg4, FieldOperand(rax, rdi, times_2, SeqTwoByteString::kHeaderSize));

__ lea(arg3, FieldOperand(rax, rbx, times_2, SeqTwoByteString::kHeaderSize));

@@ -9827,15 +9824,15 @@ void StringAddStub::Generate(MacroAssembler* masm) {

// rdx: second string

// Check if either of the strings are empty. In that case return the other.

Label second_not_zero_length, both_not_zero_length;

- __ movq(rcx, FieldOperand(rdx, String::kLengthOffset));

- __ SmiTest(rcx);

+ __ movl(rcx, FieldOperand(rdx, String::kLengthOffset));

+ __ testl(rcx, rcx);

__ j(not_zero, &second_not_zero_length);

// Second string is empty, result is first string which is already in rax.

__ IncrementCounter(&Counters::string_add_native, 1);

__ ret(2 * kPointerSize);

__ bind(&second_not_zero_length);

- __ movq(rbx, FieldOperand(rax, String::kLengthOffset));

- __ SmiTest(rbx);

+ __ movl(rbx, FieldOperand(rax, String::kLengthOffset));

+ __ testl(rbx, rbx);

__ j(not_zero, &both_not_zero_length);

// First string is empty, result is second string which is in rdx.

__ movq(rax, rdx);

@@ -9863,11 +9860,10 @@ void StringAddStub::Generate(MacroAssembler* masm) {

__ movzxbl(r9, FieldOperand(r9, Map::kInstanceTypeOffset));

// Look at the length of the result of adding the two strings.

- ASSERT(String::kMaxLength <= Smi::kMaxValue / 2);

- __ SmiAdd(rbx, rbx, rcx, NULL);

+ __ addl(rbx, rcx);

// Use the runtime system when adding two one character strings, as it

// contains optimizations for this specific case using the symbol table.

- __ SmiCompare(rbx, Smi::FromInt(2));

+ __ cmpl(rbx, Immediate(2));

__ j(not_equal, &longer_than_two);

// Check that both strings are non-external ascii strings.

@@ -9892,11 +9888,11 @@ void StringAddStub::Generate(MacroAssembler* masm) {

__ bind(&longer_than_two);

// Check if resulting string will be flat.

- __ SmiCompare(rbx, Smi::FromInt(String::kMinNonFlatLength));

+ __ cmpl(rbx, Immediate(String::kMinNonFlatLength));

__ j(below, &string_add_flat_result);

// Handle exceptionally long strings in the runtime system.

ASSERT((String::kMaxLength & 0x80000000) == 0);

- __ SmiCompare(rbx, Smi::FromInt(String::kMaxLength));

+ __ cmpl(rbx, Immediate(String::kMaxLength));

__ j(above, &string_add_runtime);

// If result is not supposed to be flat, allocate a cons string object. If

@@ -9916,7 +9912,7 @@ void StringAddStub::Generate(MacroAssembler* masm) {

__ AllocateAsciiConsString(rcx, rdi, no_reg, &string_add_runtime);

__ bind(&allocated);

// Fill the fields of the cons string.

- __ movq(FieldOperand(rcx, ConsString::kLengthOffset), rbx);

+ __ movl(FieldOperand(rcx, ConsString::kLengthOffset), rbx);

__ movl(FieldOperand(rcx, ConsString::kHashFieldOffset),

Immediate(String::kEmptyHashField));

__ movq(FieldOperand(rcx, ConsString::kFirstOffset), rax);

@@ -9932,12 +9928,11 @@ void StringAddStub::Generate(MacroAssembler* masm) {

// Handle creating a flat result. First check that both strings are not

// external strings.

// rax: first string

- // ebx: length of resulting flat string as smi

+ // ebx: length of resulting flat string

// rdx: second string

// r8: instance type of first string

// r9: instance type of first string

__ bind(&string_add_flat_result);

- __ SmiToInteger32(rbx, rbx);

__ movl(rcx, r8);

__ and_(rcx, Immediate(kStringRepresentationMask));

__ cmpl(rcx, Immediate(kExternalStringTag));

@@ -9967,8 +9962,7 @@ void StringAddStub::Generate(MacroAssembler* masm) {

// Locate first character of result.

__ addq(rcx, Immediate(SeqAsciiString::kHeaderSize - kHeapObjectTag));

// Locate first character of first argument

- __ movq(rdi, FieldOperand(rax, String::kLengthOffset));

- __ SmiToInteger32(rdi, rdi);

+ __ movl(rdi, FieldOperand(rax, String::kLengthOffset));

__ addq(rax, Immediate(SeqAsciiString::kHeaderSize - kHeapObjectTag));

// rax: first char of first argument

// rbx: result string

@@ -9977,8 +9971,7 @@ void StringAddStub::Generate(MacroAssembler* masm) {

// rdi: length of first argument

GenerateCopyCharacters(masm, rcx, rax, rdi, true);

// Locate first character of second argument.

- __ movq(rdi, FieldOperand(rdx, String::kLengthOffset));

- __ SmiToInteger32(rdi, rdi);

+ __ movl(rdi, FieldOperand(rdx, String::kLengthOffset));

__ addq(rdx, Immediate(SeqAsciiString::kHeaderSize - kHeapObjectTag));

// rbx: result string

// rcx: next character of result

@@ -10006,8 +9999,7 @@ void StringAddStub::Generate(MacroAssembler* masm) {

// Locate first character of result.

__ addq(rcx, Immediate(SeqTwoByteString::kHeaderSize - kHeapObjectTag));

// Locate first character of first argument.

- __ movq(rdi, FieldOperand(rax, String::kLengthOffset));

- __ SmiToInteger32(rdi, rdi);

+ __ movl(rdi, FieldOperand(rax, String::kLengthOffset));

__ addq(rax, Immediate(SeqTwoByteString::kHeaderSize - kHeapObjectTag));

// rax: first char of first argument

// rbx: result string

@@ -10016,8 +10008,7 @@ void StringAddStub::Generate(MacroAssembler* masm) {

// rdi: length of first argument

GenerateCopyCharacters(masm, rcx, rax, rdi, false);

// Locate first character of second argument.

- __ movq(rdi, FieldOperand(rdx, String::kLengthOffset));

- __ SmiToInteger32(rdi, rdi);

+ __ movl(rdi, FieldOperand(rdx, String::kLengthOffset));

__ addq(rdx, Immediate(SeqTwoByteString::kHeaderSize - kHeapObjectTag));

// rbx: result string

// rcx: next character of result

@@ -10199,8 +10190,7 @@ void StringStubBase::GenerateTwoCharacterSymbolTableProbe(MacroAssembler* masm,

__ j(equal, not_found);

// If length is not 2 the string is not a candidate.

- __ SmiCompare(FieldOperand(candidate, String::kLengthOffset),

- Smi::FromInt(2));

+ __ cmpl(FieldOperand(candidate, String::kLengthOffset), Immediate(2));

__ j(not_equal, &next_probe[i]);

// We use kScratchRegister as a temporary register in assumption that

@@ -10444,12 +10434,9 @@ void StringCompareStub::GenerateCompareFlatAsciiStrings(MacroAssembler* masm,

ASSERT(String::kMaxLength < 0x7fffffff);

// Find minimum length and length difference.

- __ movq(scratch1, FieldOperand(left, String::kLengthOffset));

- __ movq(scratch4, scratch1);

- __ SmiSub(scratch4,

- scratch4,

- FieldOperand(right, String::kLengthOffset),

- NULL);

+ __ movl(scratch1, FieldOperand(left, String::kLengthOffset));

+ __ movl(scratch4, scratch1);

+ __ subl(scratch4, FieldOperand(right, String::kLengthOffset));

// Register scratch4 now holds left.length - right.length.

const Register length_difference = scratch4;

Label left_shorter;

@@ -10457,18 +10444,16 @@ void StringCompareStub::GenerateCompareFlatAsciiStrings(MacroAssembler* masm,

// The right string isn't longer that the left one.

// Get the right string's length by subtracting the (non-negative) difference

// from the left string's length.

- __ SmiSub(scratch1, scratch1, length_difference, NULL);

+ __ subl(scratch1, length_difference);

__ bind(&left_shorter);

// Register scratch1 now holds Min(left.length, right.length).

const Register min_length = scratch1;

Label compare_lengths;

// If min-length is zero, go directly to comparing lengths.

- __ SmiTest(min_length);

+ __ testl(min_length, min_length);

__ j(zero, &compare_lengths);

- __ SmiToInteger32(min_length, min_length);

// Registers scratch2 and scratch3 are free.

Label result_not_equal;

Label loop;

@@ -10499,7 +10484,7 @@ void StringCompareStub::GenerateCompareFlatAsciiStrings(MacroAssembler* masm,

// Completed loop without finding different characters.

// Compare lengths (precomputed).

__ bind(&compare_lengths);

- __ SmiTest(length_difference);

+ __ testl(length_difference, length_difference);

__ j(not_zero, &result_not_equal);

// Result is EQUAL.

« no previous file with comments | « src/objects-inl.h ('k') | src/x64/macro-assembler-x64.h » ('j') | no next file with comments »