src/arm/ic-arm.cc - Issue 12330012: ES6 symbols: Allow symbols as property names

Unified Diff: src/arm/ic-arm.cc

Issue 12330012: ES6 symbols: Allow symbols as property names (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge

Patch Set: Platform ports 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/ic-arm.cc

diff --git a/src/arm/ic-arm.cc b/src/arm/ic-arm.cc

index 9c41e734ab9caba36bd7a3bf8103edc88459678b..4fb58781f27f9ff6d0c124a37f7f249df11e8603 100644

--- a/src/arm/ic-arm.cc

+++ b/src/arm/ic-arm.cc

@@ -64,12 +64,12 @@ static void GenerateGlobalInstanceTypeCheck(MacroAssembler* masm,

// Generated code falls through if the receiver is a regular non-global

// JS object with slow properties and no interceptors.

-static void GenerateStringDictionaryReceiverCheck(MacroAssembler* masm,

- Register receiver,

- Register elements,

- Register t0,

- Register t1,

- Label* miss) {

+static void GenerateNameDictionaryReceiverCheck(MacroAssembler* masm,

+ Register receiver,

+ Register elements,

+ Register t0,

+ Register t1,

+ Label* miss) {

// Register usage:

// receiver: holds the receiver on entry and is unchanged.

// elements: holds the property dictionary on fall through.

@@ -131,19 +131,19 @@ static void GenerateDictionaryLoad(MacroAssembler* masm,

Label done;

// Probe the dictionary.

- StringDictionaryLookupStub::GeneratePositiveLookup(masm,

- miss,

- &done,

- elements,

- name,

- scratch1,

- scratch2);

+ NameDictionaryLookupStub::GeneratePositiveLookup(masm,

+ miss,

+ &done,

+ elements,

+ name,

+ scratch1,

+ scratch2);

// If probing finds an entry check that the value is a normal

// property.

__ bind(&done); // scratch2 == elements + 4 * index

- const int kElementsStartOffset = StringDictionary::kHeaderSize +

- StringDictionary::kElementsStartIndex * kPointerSize;

+ const int kElementsStartOffset = NameDictionary::kHeaderSize +

+ NameDictionary::kElementsStartIndex * kPointerSize;

const int kDetailsOffset = kElementsStartOffset + 2 * kPointerSize;

__ ldr(scratch1, FieldMemOperand(scratch2, kDetailsOffset));

__ tst(scratch1, Operand(PropertyDetails::TypeField::kMask << kSmiTagSize));

@@ -180,19 +180,19 @@ static void GenerateDictionaryStore(MacroAssembler* masm,

Label done;

// Probe the dictionary.

- StringDictionaryLookupStub::GeneratePositiveLookup(masm,

- miss,

- &done,

- elements,

- name,

- scratch1,

- scratch2);

+ NameDictionaryLookupStub::GeneratePositiveLookup(masm,

+ miss,

+ &done,

+ elements,

+ name,

+ scratch1,

+ scratch2);

// If probing finds an entry in the dictionary check that the value

// is a normal property that is not read only.

__ bind(&done); // scratch2 == elements + 4 * index

- const int kElementsStartOffset = StringDictionary::kHeaderSize +

- StringDictionary::kElementsStartIndex * kPointerSize;

+ const int kElementsStartOffset = NameDictionary::kHeaderSize +

+ NameDictionary::kElementsStartIndex * kPointerSize;

const int kDetailsOffset = kElementsStartOffset + 2 * kPointerSize;

const int kTypeAndReadOnlyMask =

(PropertyDetails::TypeField::kMask |

@@ -303,22 +303,25 @@ static void GenerateFastArrayLoad(MacroAssembler* masm,

}

-// Checks whether a key is an array index string or an internalized string.

-// Falls through if a key is an internalized string.

-static void GenerateKeyStringCheck(MacroAssembler* masm,

- Register key,

- Register map,

- Register hash,

- Label* index_string,

- Label* not_internalized) {

+// Checks whether a key is an array index string or a unique name.

+// Falls through if a key is a unique name.

+static void GenerateKeyNameCheck(MacroAssembler* masm,

+ Register key,

+ Register map,

+ Register hash,

+ Label* index_string,

+ Label* not_unique) {

// The key is not a smi.

- // Is it a string?

- __ CompareObjectType(key, map, hash, FIRST_NONSTRING_TYPE);

- __ b(ge, not_internalized);

+ Label unique;

+ // Is it a name?

+ __ CompareObjectType(key, map, hash, LAST_UNIQUE_NAME_TYPE);

+ __ b(hi, not_unique);

+ STATIC_ASSERT(LAST_UNIQUE_NAME_TYPE == FIRST_NONSTRING_TYPE);

+ __ b(eq, &unique);

// Is the string an array index, with cached numeric value?

- __ ldr(hash, FieldMemOperand(key, String::kHashFieldOffset));

- __ tst(hash, Operand(String::kContainsCachedArrayIndexMask));

+ __ ldr(hash, FieldMemOperand(key, Name::kHashFieldOffset));

+ __ tst(hash, Operand(Name::kContainsCachedArrayIndexMask));

__ b(eq, index_string);

// Is the string internalized?

@@ -326,7 +329,9 @@ static void GenerateKeyStringCheck(MacroAssembler* masm,

__ ldrb(hash, FieldMemOperand(map, Map::kInstanceTypeOffset));

STATIC_ASSERT(kInternalizedTag != 0);

__ tst(hash, Operand(kIsInternalizedMask));

- __ b(eq, not_internalized);

+ __ b(eq, not_unique);

+ __ bind(&unique);

}

@@ -427,7 +432,7 @@ void CallICBase::GenerateNormal(MacroAssembler* masm, int argc) {

// Get the receiver of the function from the stack into r1.

__ ldr(r1, MemOperand(sp, argc * kPointerSize));

- GenerateStringDictionaryReceiverCheck(masm, r1, r0, r3, r4, &miss);

+ GenerateNameDictionaryReceiverCheck(masm, r1, r0, r3, r4, &miss);

// r0: elements

// Search the dictionary - put result in register r1.

@@ -531,11 +536,11 @@ void KeyedCallIC::GenerateMegamorphic(MacroAssembler* masm, int argc) {

__ ldr(r1, MemOperand(sp, argc * kPointerSize));

Label do_call, slow_call, slow_load, slow_reload_receiver;

- Label check_number_dictionary, check_string, lookup_monomorphic_cache;

- Label index_smi, index_string;

+ Label check_number_dictionary, check_name, lookup_monomorphic_cache;

+ Label index_smi, index_name;

// Check that the key is a smi.

- __ JumpIfNotSmi(r2, &check_string);

+ __ JumpIfNotSmi(r2, &check_name);

__ bind(&index_smi);

// Now the key is known to be a smi. This place is also jumped to from below

// where a numeric string is converted to a smi.

@@ -582,10 +587,10 @@ void KeyedCallIC::GenerateMegamorphic(MacroAssembler* masm, int argc) {

__ mov(r1, r0);

__ jmp(&do_call);

- __ bind(&check_string);

- GenerateKeyStringCheck(masm, r2, r0, r3, &index_string, &slow_call);

+ __ bind(&check_name);

+ GenerateKeyNameCheck(masm, r2, r0, r3, &index_name, &slow_call);

- // The key is known to be internalized.

+ // The key is known to be a uniquq name.

// If the receiver is a regular JS object with slow properties then do

// a quick inline probe of the receiver's dictionary.

// Otherwise do the monomorphic cache probe.

@@ -613,14 +618,14 @@ void KeyedCallIC::GenerateMegamorphic(MacroAssembler* masm, int argc) {

__ bind(&slow_call);

// This branch is taken if:

// - the receiver requires boxing or access check,

- // - the key is neither smi nor an internalized string,

+ // - the key is neither smi nor a unique name,

// - the value loaded is not a function,

// - there is hope that the runtime will create a monomorphic call stub

// that will get fetched next time.

__ IncrementCounter(counters->keyed_call_generic_slow(), 1, r0, r3);

GenerateMiss(masm, argc);

- __ bind(&index_string);

+ __ bind(&index_name);

__ IndexFromHash(r3, r2);

// Now jump to the place where smi keys are handled.

__ jmp(&index_smi);

@@ -633,10 +638,10 @@ void KeyedCallIC::GenerateNormal(MacroAssembler* masm, int argc) {

// -- lr : return address

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

- // Check if the name is a string.

+ // Check if the name is really a name.

Label miss;

__ JumpIfSmi(r2, &miss);

- __ IsObjectJSStringType(r2, r0, &miss);

+ __ IsObjectNameType(r2, r0, &miss);

CallICBase::GenerateNormal(masm, argc);

__ bind(&miss);

@@ -675,7 +680,7 @@ void LoadIC::GenerateNormal(MacroAssembler* masm) {

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

Label miss;

- GenerateStringDictionaryReceiverCheck(masm, r0, r1, r3, r4, &miss);

+ GenerateNameDictionaryReceiverCheck(masm, r0, r1, r3, r4, &miss);

// r1: elements

GenerateDictionaryLoad(masm, &miss, r1, r2, r0, r3, r4);

@@ -918,7 +923,7 @@ void KeyedLoadIC::GenerateGeneric(MacroAssembler* masm) {

// -- r0 : key

// -- r1 : receiver

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

- Label slow, check_string, index_smi, index_string, property_array_property;

+ Label slow, check_name, index_smi, index_name, property_array_property;

Label probe_dictionary, check_number_dictionary;

@@ -927,7 +932,7 @@ void KeyedLoadIC::GenerateGeneric(MacroAssembler* masm) {

Isolate* isolate = masm->isolate();

// Check that the key is a smi.

- __ JumpIfNotSmi(key, &check_string);

+ __ JumpIfNotSmi(key, &check_name);

__ bind(&index_smi);

// Now the key is known to be a smi. This place is also jumped to from below

// where a numeric string is converted to a smi.

@@ -964,8 +969,8 @@ void KeyedLoadIC::GenerateGeneric(MacroAssembler* masm) {

1, r2, r3);

GenerateRuntimeGetProperty(masm);

- __ bind(&check_string);

- GenerateKeyStringCheck(masm, key, r2, r3, &index_string, &slow);

+ __ bind(&check_name);

+ GenerateKeyNameCheck(masm, key, r2, r3, &index_name, &slow);

GenerateKeyedLoadReceiverCheck(

masm, receiver, r2, r3, Map::kHasNamedInterceptor, &slow);

@@ -1076,7 +1081,7 @@ void KeyedLoadIC::GenerateGeneric(MacroAssembler* masm) {

isolate->counters()->keyed_load_generic_symbol(), 1, r2, r3);

__ Ret();

- __ bind(&index_string);

+ __ bind(&index_name);

__ IndexFromHash(r3, key);

// Now jump to the place where smi keys are handled.

__ jmp(&index_smi);

@@ -1547,7 +1552,7 @@ void StoreIC::GenerateNormal(MacroAssembler* masm) {

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

Label miss;

- GenerateStringDictionaryReceiverCheck(masm, r1, r3, r4, r5, &miss);

+ GenerateNameDictionaryReceiverCheck(masm, r1, r3, r4, r5, &miss);

GenerateDictionaryStore(masm, &miss, r3, r2, r0, r4, r5);

Counters* counters = masm->isolate()->counters();

« no previous file with comments | « src/arm/code-stubs-arm.cc ('k') | src/arm/macro-assembler-arm.h » ('j') | no next file with comments »