src/arm/code-stubs-arm.cc - Issue 12210083: Renamed "symbols" to "internalized strings" throughout the code base,

Unified Diff: src/arm/code-stubs-arm.cc

Issue 12210083: Renamed "symbols" to "internalized strings" throughout the code base, (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge

Patch Set: Created 7 years, 10 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

Download patch

Index: src/arm/code-stubs-arm.cc

diff --git a/src/arm/code-stubs-arm.cc b/src/arm/code-stubs-arm.cc

index 62fcc9a981ccd5946ed7946d006d7e6d5224d4d1..0b3693ea0ce21cd004458d218bfaa885d019266d 100644

--- a/src/arm/code-stubs-arm.cc

+++ b/src/arm/code-stubs-arm.cc

@@ -1535,12 +1535,13 @@ static void EmitStrictTwoHeapObjectCompare(MacroAssembler* masm,

__ cmp(r3, Operand(ODDBALL_TYPE));

__ b(eq, &return_not_equal);

- // Now that we have the types we might as well check for symbol-symbol.

- // Ensure that no non-strings have the symbol bit set.

- STATIC_ASSERT(LAST_TYPE < kNotStringTag + kIsSymbolMask);

- STATIC_ASSERT(kSymbolTag != 0);

+ // Now that we have the types we might as well check for

+ // internalized-internalized.

+ // Ensure that no non-strings have the internalized bit set.

+ STATIC_ASSERT(LAST_TYPE < kNotStringTag + kIsInternalizedMask);

+ STATIC_ASSERT(kInternalizedTag != 0);

__ and_(r2, r2, Operand(r3));

- __ tst(r2, Operand(kIsSymbolMask));

+ __ tst(r2, Operand(kIsInternalizedMask));

__ b(ne, &return_not_equal);

}

@@ -1577,29 +1578,29 @@ static void EmitCheckForTwoHeapNumbers(MacroAssembler* masm,

}

-// Fast negative check for symbol-to-symbol equality.

-static void EmitCheckForSymbolsOrObjects(MacroAssembler* masm,

- Register lhs,

- Register rhs,

- Label* possible_strings,

- Label* not_both_strings) {

+// Fast negative check for internalized-to-internalized equality.

+static void EmitCheckForInternalizedStringsOrObjects(MacroAssembler* masm,

+ Register lhs,

+ Register rhs,

+ Label* possible_strings,

+ Label* not_both_strings) {

ASSERT((lhs.is(r0) && rhs.is(r1)) ||

(lhs.is(r1) && rhs.is(r0)));

// r2 is object type of rhs.

- // Ensure that no non-strings have the symbol bit set.

+ // Ensure that no non-strings have the internalized bit set.

Label object_test;

- STATIC_ASSERT(kSymbolTag != 0);

+ STATIC_ASSERT(kInternalizedTag != 0);

__ tst(r2, Operand(kIsNotStringMask));

__ b(ne, &object_test);

- __ tst(r2, Operand(kIsSymbolMask));

+ __ tst(r2, Operand(kIsInternalizedMask));

__ b(eq, possible_strings);

__ CompareObjectType(lhs, r3, r3, FIRST_NONSTRING_TYPE);

__ b(ge, not_both_strings);

- __ tst(r3, Operand(kIsSymbolMask));

+ __ tst(r3, Operand(kIsInternalizedMask));

__ b(eq, possible_strings);

- // Both are symbols. We already checked they weren't the same pointer

+ // Both are internalized. We already checked they weren't the same pointer

// so they are not equal.

__ mov(r0, Operand(NOT_EQUAL));

__ Ret();

@@ -1746,7 +1747,7 @@ static void ICCompareStub_CheckInputType(MacroAssembler* masm,

__ CheckMap(input, scratch, Heap::kHeapNumberMapRootIndex, fail,

DONT_DO_SMI_CHECK);

}

- // We could be strict about symbol/string here, but as long as

+ // We could be strict about internalized/string here, but as long as

Yang 2013/02/11 12:26:36 suggest to change to "... about internatilized/non

rossberg 2013/02/11 13:30:16 Done.

// hydrogen doesn't care, the stub doesn't have to care either.

__ bind(&ok);

}

@@ -1844,27 +1845,29 @@ void ICCompareStub::GenerateGeneric(MacroAssembler* masm) {

EmitStrictTwoHeapObjectCompare(masm, lhs, rhs);

}

- Label check_for_symbols;

+ Label check_for_internalized_strings;

Label flat_string_check;

// Check for heap-number-heap-number comparison. Can jump to slow case,

// or load both doubles into r0, r1, r2, r3 and jump to the code that handles

- // that case. If the inputs are not doubles then jumps to check_for_symbols.

+ // that case. If the inputs are not doubles then jumps to

+ // check_for_internalized_strings.

// In this case r2 will contain the type of rhs_. Never falls through.

EmitCheckForTwoHeapNumbers(masm,

lhs,

rhs,

&both_loaded_as_doubles,

- &check_for_symbols,

+ &check_for_internalized_strings,

&flat_string_check);

- __ bind(&check_for_symbols);

+ __ bind(&check_for_internalized_strings);

// In the strict case the EmitStrictTwoHeapObjectCompare already took care of

- // symbols.

+ // internalized strings.

if (cc == eq && !strict()) {

- // Returns an answer for two symbols or two detectable objects.

+ // Returns an answer for two internalized strings or two detectable objects.

// Otherwise jumps to string case or not both strings case.

// Assumes that r2 is the type of rhs_ on entry.

- EmitCheckForSymbolsOrObjects(masm, lhs, rhs, &flat_string_check, &slow);

+ EmitCheckForInternalizedStringsOrObjects(

+ masm, lhs, rhs, &flat_string_check, &slow);

}

// Check for both being sequential ASCII strings, and inline if that is the

@@ -4533,7 +4536,7 @@ void ArrayLengthStub::Generate(MacroAssembler* masm) {

// -- r0 : key

// -- r1 : receiver

// -----------------------------------

- __ cmp(r0, Operand(masm->isolate()->factory()->length_symbol()));

+ __ cmp(r0, Operand(masm->isolate()->factory()->length_string()));

__ b(ne, &miss);

receiver = r1;

} else {

@@ -4562,7 +4565,7 @@ void FunctionPrototypeStub::Generate(MacroAssembler* masm) {

// -- r0 : key

// -- r1 : receiver

// -----------------------------------

- __ cmp(r0, Operand(masm->isolate()->factory()->prototype_symbol()));

+ __ cmp(r0, Operand(masm->isolate()->factory()->prototype_string()));

__ b(ne, &miss);

receiver = r1;

} else {

@@ -4591,7 +4594,7 @@ void StringLengthStub::Generate(MacroAssembler* masm) {

// -- r0 : key

// -- r1 : receiver

// -----------------------------------

- __ cmp(r0, Operand(masm->isolate()->factory()->length_symbol()));

+ __ cmp(r0, Operand(masm->isolate()->factory()->length_string()));

__ b(ne, &miss);

receiver = r1;

} else {

@@ -4629,7 +4632,7 @@ void StoreArrayLengthStub::Generate(MacroAssembler* masm) {

// -- r1 : key

// -- r2 : receiver

// -----------------------------------

- __ cmp(r1, Operand(masm->isolate()->factory()->length_symbol()));

+ __ cmp(r1, Operand(masm->isolate()->factory()->length_string()));

__ b(ne, &miss);

receiver = r2;

value = r0;

@@ -5233,7 +5236,7 @@ void RegExpExecStub::Generate(MacroAssembler* masm) {

// String is a cons string, check whether it is flat.

__ bind(&cons_string);

__ ldr(r0, FieldMemOperand(subject, ConsString::kSecondOffset));

- __ CompareRoot(r0, Heap::kEmptyStringRootIndex);

+ __ CompareRoot(r0, Heap::kempty_stringRootIndex);

__ b(ne, &runtime);

__ ldr(subject, FieldMemOperand(subject, ConsString::kFirstOffset));

// Is first part of cons or parent of slice a flat string?

@@ -6078,7 +6081,7 @@ void StringHelper::GenerateCopyCharactersLong(MacroAssembler* masm,

}

-void StringHelper::GenerateTwoCharacterSymbolTableProbe(MacroAssembler* masm,

+void StringHelper::GenerateTwoCharacterStringTableProbe(MacroAssembler* masm,

@@ -6091,7 +6094,7 @@ void StringHelper::GenerateTwoCharacterSymbolTableProbe(MacroAssembler* masm,

// Make sure that both characters are not digits as such strings has a

- // different hash algorithm. Don't try to look for these in the symbol table.

+ // different hash algorithm. Don't try to look for these in the string table.

Label not_array_index;

__ sub(scratch, c1, Operand(static_cast<int>('0')));

__ cmp(scratch, Operand(static_cast<int>('9' - '0')));

@@ -6119,43 +6122,43 @@ void StringHelper::GenerateTwoCharacterSymbolTableProbe(MacroAssembler* masm,

// chars: two character string, char 1 in byte 0 and char 2 in byte 1.

// hash: hash of two character string.

- // Load symbol table

- // Load address of first element of the symbol table.

- Register symbol_table = c2;

- __ LoadRoot(symbol_table, Heap::kSymbolTableRootIndex);

+ // Load string table

+ // Load address of first element of the string table.

+ Register string_table = c2;

+ __ LoadRoot(string_table, Heap::kStringTableRootIndex);

__ LoadRoot(undefined, Heap::kUndefinedValueRootIndex);

- // Calculate capacity mask from the symbol table capacity.

+ // Calculate capacity mask from the string table capacity.

- __ ldr(mask, FieldMemOperand(symbol_table, SymbolTable::kCapacityOffset));

+ __ ldr(mask, FieldMemOperand(string_table, StringTable::kCapacityOffset));

__ mov(mask, Operand(mask, ASR, 1));

__ sub(mask, mask, Operand(1));

- // Calculate untagged address of the first element of the symbol table.

- Register first_symbol_table_element = symbol_table;

- __ add(first_symbol_table_element, symbol_table,

- Operand(SymbolTable::kElementsStartOffset - kHeapObjectTag));

+ // Calculate untagged address of the first element of the string table.

+ Register first_string_table_element = string_table;

+ __ add(first_string_table_element, string_table,

+ Operand(StringTable::kElementsStartOffset - kHeapObjectTag));

// Registers

// chars: two character string, char 1 in byte 0 and char 2 in byte 1.

// hash: hash of two character string

// mask: capacity mask

- // first_symbol_table_element: address of the first element of

- // the symbol table

+ // first_string_table_element: address of the first element of

+ // the string table

// undefined: the undefined object

// scratch: -

- // Perform a number of probes in the symbol table.

+ // Perform a number of probes in the string table.

const int kProbes = 4;

- Label found_in_symbol_table;

+ Label found_in_string_table;

Label next_probe[kProbes];

for (int i = 0; i < kProbes; i++) {

- // Calculate entry in symbol table.

+ // Calculate entry in string table.

if (i > 0) {

- __ add(candidate, hash, Operand(SymbolTable::GetProbeOffset(i)));

+ __ add(candidate, hash, Operand(StringTable::GetProbeOffset(i)));

} else {

__ mov(candidate, hash);

}

@@ -6163,9 +6166,9 @@ void StringHelper::GenerateTwoCharacterSymbolTableProbe(MacroAssembler* masm,

__ and_(candidate, candidate, Operand(mask));

// Load the entry from the symble table.

- STATIC_ASSERT(SymbolTable::kEntrySize == 1);

+ STATIC_ASSERT(StringTable::kEntrySize == 1);

__ ldr(candidate,

- MemOperand(first_symbol_table_element,

+ MemOperand(first_string_table_element,

candidate,

LSL,

kPointerSizeLog2));

@@ -6181,7 +6184,7 @@ void StringHelper::GenerateTwoCharacterSymbolTableProbe(MacroAssembler* masm,

if (FLAG_debug_code) {

__ LoadRoot(ip, Heap::kTheHoleValueRootIndex);

__ cmp(ip, candidate);

- __ Assert(eq, "oddball in symbol table is not undefined or the hole");

+ __ Assert(eq, "oddball in string table is not undefined or the hole");

}

__ jmp(&next_probe[i]);

@@ -6201,7 +6204,7 @@ void StringHelper::GenerateTwoCharacterSymbolTableProbe(MacroAssembler* masm,

// Assumes that word load is little endian.

__ ldrh(scratch, FieldMemOperand(candidate, SeqOneByteString::kHeaderSize));

__ cmp(chars, scratch);

- __ b(eq, &found_in_symbol_table);

+ __ b(eq, &found_in_string_table);

__ bind(&next_probe[i]);

}

@@ -6210,7 +6213,7 @@ void StringHelper::GenerateTwoCharacterSymbolTableProbe(MacroAssembler* masm,

// Scratch register contains result when we fall through to here.

- __ bind(&found_in_symbol_table);

+ __ bind(&found_in_string_table);

__ Move(r0, result);

}

@@ -6335,7 +6338,7 @@ void SubStringStub::Generate(MacroAssembler* masm) {

__ b(ne, &sliced_string);

// Cons string. Check whether it is flat, then fetch first part.

__ ldr(r5, FieldMemOperand(r0, ConsString::kSecondOffset));

- __ CompareRoot(r5, Heap::kEmptyStringRootIndex);

+ __ CompareRoot(r5, Heap::kempty_stringRootIndex);

__ b(ne, &runtime);

__ ldr(r5, FieldMemOperand(r0, ConsString::kFirstOffset));

// Update instance type.

@@ -6695,8 +6698,8 @@ void StringAddStub::Generate(MacroAssembler* masm) {

// Adding two lengths can't overflow.

STATIC_ASSERT(String::kMaxLength < String::kMaxLength * 2);

__ add(r6, r2, Operand(r3));

- // Use the symbol table when adding two one character strings, as it

- // helps later optimizations to return a symbol here.

+ // Use the string table when adding two one character strings, as it

+ // helps later optimizations to return a string here.

__ cmp(r6, Operand(2));

__ b(ne, &longer_than_two);

@@ -6714,10 +6717,10 @@ void StringAddStub::Generate(MacroAssembler* masm) {

__ ldrb(r2, FieldMemOperand(r0, SeqOneByteString::kHeaderSize));

__ ldrb(r3, FieldMemOperand(r1, SeqOneByteString::kHeaderSize));

- // Try to lookup two character string in symbol table. If it is not found

+ // Try to lookup two character string in string table. If it is not found

// just allocate a new one.

Label make_two_character_string;

- StringHelper::GenerateTwoCharacterSymbolTableProbe(

+ StringHelper::GenerateTwoCharacterStringTableProbe(

masm, r2, r3, r6, r7, r4, r5, r9, &make_two_character_string);

__ IncrementCounter(counters->string_add_native(), 1, r2, r3);

__ add(sp, sp, Operand(2 * kPointerSize));

@@ -7058,8 +7061,8 @@ void ICCompareStub::GenerateHeapNumbers(MacroAssembler* masm) {

}

-void ICCompareStub::GenerateSymbols(MacroAssembler* masm) {

- ASSERT(state_ == CompareIC::SYMBOL);

+void ICCompareStub::GenerateInternalizedStrings(MacroAssembler* masm) {

+ ASSERT(state_ == CompareIC::INTERNALIZED_STRING);

Label miss;

// Registers containing left and right operands respectively.

@@ -7071,17 +7074,17 @@ void ICCompareStub::GenerateSymbols(MacroAssembler* masm) {

// Check that both operands are heap objects.

__ JumpIfEitherSmi(left, right, &miss);

- // Check that both operands are symbols.

+ // Check that both operands are internalized strings.

__ ldr(tmp1, FieldMemOperand(left, HeapObject::kMapOffset));

__ ldr(tmp2, FieldMemOperand(right, HeapObject::kMapOffset));

__ ldrb(tmp1, FieldMemOperand(tmp1, Map::kInstanceTypeOffset));

__ ldrb(tmp2, FieldMemOperand(tmp2, Map::kInstanceTypeOffset));

- STATIC_ASSERT(kSymbolTag != 0);

+ STATIC_ASSERT(kInternalizedTag != 0);

__ and_(tmp1, tmp1, Operand(tmp2));

- __ tst(tmp1, Operand(kIsSymbolMask));

+ __ tst(tmp1, Operand(kIsInternalizedMask));

__ b(eq, &miss);

- // Symbols are compared by identity.

+ // Internalized strings are compared by identity.

__ cmp(left, right);

// Make sure r0 is non-zero. At this point input operands are

// guaranteed to be non-zero.

@@ -7133,13 +7136,13 @@ void ICCompareStub::GenerateStrings(MacroAssembler* masm) {

// Handle not identical strings.

- // Check that both strings are symbols. If they are, we're done

+ // Check that both strings are internalized strings. If they are, we're done

// because we already know they are not identical.

if (equality) {

ASSERT(GetCondition() == eq);

- STATIC_ASSERT(kSymbolTag != 0);

+ STATIC_ASSERT(kInternalizedTag != 0);

__ and_(tmp3, tmp1, Operand(tmp2));

- __ tst(tmp3, Operand(kIsSymbolMask));

+ __ tst(tmp3, Operand(kIsInternalizedMask));

// Make sure r0 is non-zero. At this point input operands are

// guaranteed to be non-zero.

ASSERT(right.is(r0));

@@ -7321,11 +7324,11 @@ void StringDictionaryLookupStub::GenerateNegativeLookup(MacroAssembler* masm,

__ cmp(entity_name, tmp);

__ b(eq, &the_hole);

- // Check if the entry name is not a symbol.

+ // Check if the entry name is not an internalized string.

__ ldr(entity_name, FieldMemOperand(entity_name, HeapObject::kMapOffset));

__ ldrb(entity_name,

FieldMemOperand(entity_name, Map::kInstanceTypeOffset));

- __ tst(entity_name, Operand(kIsSymbolMask));

+ __ tst(entity_name, Operand(kIsInternalizedMask));

__ b(eq, miss);

__ bind(&the_hole);

@@ -7494,11 +7497,11 @@ void StringDictionaryLookupStub::Generate(MacroAssembler* masm) {

__ b(eq, &in_dictionary);

if (i != kTotalProbes - 1 && mode_ == NEGATIVE_LOOKUP) {

- // Check if the entry name is not a symbol.

+ // Check if the entry name is not an internalized string.

__ ldr(entry_key, FieldMemOperand(entry_key, HeapObject::kMapOffset));

__ ldrb(entry_key,

FieldMemOperand(entry_key, Map::kInstanceTypeOffset));

- __ tst(entry_key, Operand(kIsSymbolMask));

+ __ tst(entry_key, Operand(kIsInternalizedMask));

__ b(eq, &maybe_in_dictionary);

}

« no previous file with comments | « src/arm/code-stubs-arm.h ('k') | src/arm/codegen-arm.cc » ('j') | src/arm/ic-arm.cc » ('J')