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

Unified Diff: src/ia32/ic-ia32.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/ia32/ic-ia32.cc

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

index 0829961ed930c243388eb913633513144d51c058..02c28ef86d77f7567634fa239ccd68fb0b89695b 100644

--- a/src/ia32/ic-ia32.cc

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

@@ -60,11 +60,11 @@ 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 r0,

- Register r1,

- Label* miss) {

+static void GenerateNameDictionaryReceiverCheck(MacroAssembler* masm,

+ Register receiver,

+ Register r0,

+ Register r1,

+ Label* miss) {

// Register usage:

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

// r0: used to hold receiver instance type.

@@ -127,21 +127,21 @@ static void GenerateDictionaryLoad(MacroAssembler* masm,

Label done;

// Probe the dictionary.

- StringDictionaryLookupStub::GeneratePositiveLookup(masm,

- miss_label,

- &done,

- elements,

- name,

- r0,

- r1);

+ NameDictionaryLookupStub::GeneratePositiveLookup(masm,

+ miss_label,

+ &done,

+ elements,

+ name,

+ r0,

+ r1);

// If probing finds an entry in the dictionary, r0 contains the

// index into the dictionary. Check that the value is a normal

// property.

__ bind(&done);

const int kElementsStartOffset =

- StringDictionary::kHeaderSize +

- StringDictionary::kElementsStartIndex * kPointerSize;

+ NameDictionary::kHeaderSize +

+ NameDictionary::kElementsStartIndex * kPointerSize;

const int kDetailsOffset = kElementsStartOffset + 2 * kPointerSize;

__ test(Operand(elements, r0, times_4, kDetailsOffset - kHeapObjectTag),

Immediate(PropertyDetails::TypeField::kMask << kSmiTagSize));

@@ -182,21 +182,21 @@ static void GenerateDictionaryStore(MacroAssembler* masm,

// Probe the dictionary.

- StringDictionaryLookupStub::GeneratePositiveLookup(masm,

- miss_label,

- &done,

- elements,

- name,

- r0,

- r1);

+ NameDictionaryLookupStub::GeneratePositiveLookup(masm,

+ miss_label,

+ &done,

+ elements,

+ name,

+ r0,

+ r1);

// If probing finds an entry in the dictionary, r0 contains the

// index into the dictionary. Check that the value is a normal

// property that is not read only.

__ bind(&done);

const int kElementsStartOffset =

- StringDictionary::kHeaderSize +

- StringDictionary::kElementsStartIndex * kPointerSize;

+ NameDictionary::kHeaderSize +

+ NameDictionary::kElementsStartIndex * kPointerSize;

const int kDetailsOffset = kElementsStartOffset + 2 * kPointerSize;

const int kTypeAndReadOnlyMask =

(PropertyDetails::TypeField::kMask |

@@ -292,31 +292,36 @@ static void GenerateFastArrayLoad(MacroAssembler* masm,

}

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

-// Falls through if the 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 the key is a unique name.

+static void GenerateKeyNameCheck(MacroAssembler* masm,

+ Register key,

+ Register map,

+ Register hash,

+ Label* index_string,

+ Label* not_unique) {

// Register use:

// key - holds the key and is unchanged. Assumed to be non-smi.

// Scratch registers:

// map - used to hold the map of the key.

// hash - used to hold the hash of the key.

- __ CmpObjectType(key, FIRST_NONSTRING_TYPE, map);

- __ j(above_equal, not_internalized);

+ Label unique;

+ __ CmpObjectType(key, LAST_UNIQUE_NAME_TYPE, map);

+ __ j(above, not_unique);

+ STATIC_ASSERT(LAST_UNIQUE_NAME_TYPE == FIRST_NONSTRING_TYPE);

+ __ j(equal, &unique);

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

- __ mov(hash, FieldOperand(key, String::kHashFieldOffset));

- __ test(hash, Immediate(String::kContainsCachedArrayIndexMask));

+ __ mov(hash, FieldOperand(key, Name::kHashFieldOffset));

+ __ test(hash, Immediate(Name::kContainsCachedArrayIndexMask));

__ j(zero, index_string);

// Is the string internalized?

STATIC_ASSERT(kInternalizedTag != 0);

__ test_b(FieldOperand(map, Map::kInstanceTypeOffset), kIsInternalizedMask);

- __ j(zero, not_internalized);

+ __ j(zero, not_unique);

+ __ bind(&unique);

}

@@ -403,11 +408,11 @@ void KeyedLoadIC::GenerateGeneric(MacroAssembler* masm) {

// -- edx : receiver

// -- esp[0] : return address

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

- 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;

// Check that the key is a smi.

- __ JumpIfNotSmi(ecx, &check_string);

+ __ JumpIfNotSmi(ecx, &check_name);

__ bind(&index_smi);

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

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

@@ -458,8 +463,8 @@ void KeyedLoadIC::GenerateGeneric(MacroAssembler* masm) {

__ IncrementCounter(counters->keyed_load_generic_slow(), 1);

GenerateRuntimeGetProperty(masm);

- __ bind(&check_string);

- GenerateKeyStringCheck(masm, ecx, eax, ebx, &index_string, &slow);

+ __ bind(&check_name);

+ GenerateKeyNameCheck(masm, ecx, eax, ebx, &index_name, &slow);

GenerateKeyedLoadReceiverCheck(

masm, edx, eax, Map::kHasNamedInterceptor, &slow);

@@ -568,7 +573,7 @@ void KeyedLoadIC::GenerateGeneric(MacroAssembler* masm) {

__ IncrementCounter(counters->keyed_load_generic_symbol(), 1);

__ ret(0);

- __ bind(&index_string);

+ __ bind(&index_name);

__ IndexFromHash(ebx, ecx);

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

__ jmp(&index_smi);

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

// Get the receiver of the function from the stack; 1 ~ return address.

__ mov(edx, Operand(esp, (argc + 1) * kPointerSize));

- GenerateStringDictionaryReceiverCheck(masm, edx, eax, ebx, &miss);

+ GenerateNameDictionaryReceiverCheck(masm, edx, eax, ebx, &miss);

// eax: elements

// Search the dictionary placing the result in edi.

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

__ mov(edx, Operand(esp, (argc + 1) * 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(ecx, &check_string);

+ __ JumpIfNotSmi(ecx, &check_name);

__ bind(&index_smi);

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

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

__ mov(edi, eax);

__ jmp(&do_call);

- __ bind(&check_string);

- GenerateKeyStringCheck(masm, ecx, eax, ebx, &index_string, &slow_call);

+ __ bind(&check_name);

+ GenerateKeyNameCheck(masm, ecx, eax, ebx, &index_name, &slow_call);

- // The key is known to be an internalized string.

+ // The key is known to be a unique 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.

@@ -1224,14 +1229,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);

GenerateMiss(masm, argc);

- __ bind(&index_string);

+ __ bind(&index_name);

__ IndexFromHash(ebx, ecx);

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

__ jmp(&index_smi);

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

// -- esp[(argc + 1) * 4] : receiver

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

- // Check if the name is a string.

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

Label miss;

__ JumpIfSmi(ecx, &miss);

- Condition cond = masm->IsObjectStringType(ecx, eax, eax);

+ Condition cond = masm->IsObjectNameType(ecx, eax, eax);

__ j(NegateCondition(cond), &miss);

CallICBase::GenerateNormal(masm, argc);

__ bind(&miss);

@@ -1312,7 +1317,7 @@ void LoadIC::GenerateNormal(MacroAssembler* masm) {

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

Label miss;

- GenerateStringDictionaryReceiverCheck(masm, edx, eax, ebx, &miss);

+ GenerateNameDictionaryReceiverCheck(masm, edx, eax, ebx, &miss);

// eax: elements

// Search the dictionary placing the result in eax.

@@ -1436,7 +1441,7 @@ void StoreIC::GenerateNormal(MacroAssembler* masm) {

Label miss, restore_miss;

- GenerateStringDictionaryReceiverCheck(masm, edx, ebx, edi, &miss);

+ GenerateNameDictionaryReceiverCheck(masm, edx, ebx, edi, &miss);

// A lot of registers are needed for storing to slow case

// objects. Push and restore receiver but rely on

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