From 8924d03e16dd9f6afb280c281ac5c4b0bc5c37e8 Mon Sep 17 00:00:00 2001 From: "rossberg@chromium.org" Date: Thu, 28 Feb 2013 14:43:57 +0000 Subject: [PATCH] Minor cleanup of CompareIC state Allow transitioning from KNOWN_OBJECT to KNONW_OBJECT or OBJECT. Also, rename HEAP_NUMBER IC states to NUMBER, since they handle Smis, too. R=jkummerow@chromium.org BUG= Review URL: https://codereview.chromium.org/12254036 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@13775 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/arm/code-stubs-arm.cc | 32 +++++++------ src/arm/code-stubs-arm.h | 6 +-- src/code-stubs.cc | 10 ++--- src/code-stubs.h | 6 +-- src/ia32/code-stubs-ia32.cc | 24 +++++----- src/ia32/code-stubs-ia32.h | 6 +-- src/ic.cc | 90 +++++++++++++++++++------------------ src/ic.h | 16 ++++--- src/mips/code-stubs-mips.h | 6 +-- src/objects.cc | 2 +- src/type-info.cc | 12 ++--- src/x64/code-stubs-x64.cc | 24 +++++----- src/x64/code-stubs-x64.h | 6 +-- 13 files changed, 123 insertions(+), 117 deletions(-) diff --git a/src/arm/code-stubs-arm.cc b/src/arm/code-stubs-arm.cc index fd2dd2c518..32759b4845 100644 --- a/src/arm/code-stubs-arm.cc +++ b/src/arm/code-stubs-arm.cc @@ -1711,7 +1711,7 @@ static void ICCompareStub_CheckInputType(MacroAssembler* masm, Label ok; if (expected == CompareIC::SMI) { __ JumpIfNotSmi(input, fail); - } else if (expected == CompareIC::HEAP_NUMBER) { + } else if (expected == CompareIC::NUMBER) { __ JumpIfSmi(input, &ok); __ CheckMap(input, scratch, Heap::kHeapNumberMapRootIndex, fail, DONT_DO_SMI_CHECK); @@ -2111,8 +2111,8 @@ void UnaryOpStub::Generate(MacroAssembler* masm) { case UnaryOpIC::SMI: GenerateSmiStub(masm); break; - case UnaryOpIC::HEAP_NUMBER: - GenerateHeapNumberStub(masm); + case UnaryOpIC::NUMBER: + GenerateNumberStub(masm); break; case UnaryOpIC::GENERIC: GenerateGenericStub(masm); @@ -2192,13 +2192,13 @@ void UnaryOpStub::GenerateSmiCodeBitNot(MacroAssembler* masm, // TODO(svenpanne): Use virtual functions instead of switch. -void UnaryOpStub::GenerateHeapNumberStub(MacroAssembler* masm) { +void UnaryOpStub::GenerateNumberStub(MacroAssembler* masm) { switch (op_) { case Token::SUB: - GenerateHeapNumberStubSub(masm); + GenerateNumberStubSub(masm); break; case Token::BIT_NOT: - GenerateHeapNumberStubBitNot(masm); + GenerateNumberStubBitNot(masm); break; default: UNREACHABLE(); @@ -2206,7 +2206,7 @@ void UnaryOpStub::GenerateHeapNumberStub(MacroAssembler* masm) { } -void UnaryOpStub::GenerateHeapNumberStubSub(MacroAssembler* masm) { +void UnaryOpStub::GenerateNumberStubSub(MacroAssembler* masm) { Label non_smi, slow, call_builtin; GenerateSmiCodeSub(masm, &non_smi, &call_builtin); __ bind(&non_smi); @@ -2218,7 +2218,7 @@ void UnaryOpStub::GenerateHeapNumberStubSub(MacroAssembler* masm) { } -void UnaryOpStub::GenerateHeapNumberStubBitNot(MacroAssembler* masm) { +void UnaryOpStub::GenerateNumberStubBitNot(MacroAssembler* masm) { Label non_smi, slow; GenerateSmiCodeBitNot(masm, &non_smi); __ bind(&non_smi); @@ -2680,8 +2680,7 @@ void BinaryOpStub_GenerateFPOperation(MacroAssembler* masm, masm, right, destination, d7, d8, r2, r3, heap_number_map, scratch1, scratch2, s0, miss); } else { - Label* fail = (right_type == BinaryOpIC::HEAP_NUMBER) ? miss - : not_numbers; + Label* fail = (right_type == BinaryOpIC::NUMBER) ? miss : not_numbers; FloatingPointHelper::LoadNumber( masm, destination, right, d7, r2, r3, heap_number_map, scratch1, scratch2, fail); @@ -2693,8 +2692,7 @@ void BinaryOpStub_GenerateFPOperation(MacroAssembler* masm, masm, left, destination, d6, d8, r0, r1, heap_number_map, scratch1, scratch2, s0, miss); } else { - Label* fail = (left_type == BinaryOpIC::HEAP_NUMBER) ? miss - : not_numbers; + Label* fail = (left_type == BinaryOpIC::NUMBER) ? miss : not_numbers; FloatingPointHelper::LoadNumber( masm, destination, left, d6, r0, r1, heap_number_map, scratch1, scratch2, fail); @@ -3090,7 +3088,7 @@ void BinaryOpStub::GenerateInt32Stub(MacroAssembler* masm) { __ bind(&return_heap_number); // Return a heap number, or fall through to type transition or runtime // call if we can't. - if (result_type_ >= ((op_ == Token::DIV) ? BinaryOpIC::HEAP_NUMBER + if (result_type_ >= ((op_ == Token::DIV) ? BinaryOpIC::NUMBER : BinaryOpIC::INT32)) { // We are using vfp registers so r5 is available. heap_number_result = r5; @@ -3314,11 +3312,11 @@ void BinaryOpStub::GenerateOddballStub(MacroAssembler* masm) { } __ bind(&done); - GenerateHeapNumberStub(masm); + GenerateNumberStub(masm); } -void BinaryOpStub::GenerateHeapNumberStub(MacroAssembler* masm) { +void BinaryOpStub::GenerateNumberStub(MacroAssembler* masm) { Label call_runtime, transition; BinaryOpStub_GenerateFPOperation( masm, left_type_, right_type_, false, @@ -6941,8 +6939,8 @@ void ICCompareStub::GenerateSmis(MacroAssembler* masm) { } -void ICCompareStub::GenerateHeapNumbers(MacroAssembler* masm) { - ASSERT(state_ == CompareIC::HEAP_NUMBER); +void ICCompareStub::GenerateNumbers(MacroAssembler* masm) { + ASSERT(state_ == CompareIC::NUMBER); Label generic_stub; Label unordered, maybe_undefined1, maybe_undefined2; diff --git a/src/arm/code-stubs-arm.h b/src/arm/code-stubs-arm.h index 7a58f0cf65..8b7b5ceb48 100644 --- a/src/arm/code-stubs-arm.h +++ b/src/arm/code-stubs-arm.h @@ -119,9 +119,9 @@ class UnaryOpStub: public PlatformCodeStub { void GenerateSmiCodeSub(MacroAssembler* masm, Label* non_smi, Label* slow); void GenerateSmiCodeBitNot(MacroAssembler* masm, Label* slow); - void GenerateHeapNumberStub(MacroAssembler* masm); - void GenerateHeapNumberStubSub(MacroAssembler* masm); - void GenerateHeapNumberStubBitNot(MacroAssembler* masm); + void GenerateNumberStub(MacroAssembler* masm); + void GenerateNumberStubSub(MacroAssembler* masm); + void GenerateNumberStubBitNot(MacroAssembler* masm); void GenerateHeapNumberCodeSub(MacroAssembler* masm, Label* slow); void GenerateHeapNumberCodeBitNot(MacroAssembler* masm, Label* slow); diff --git a/src/code-stubs.cc b/src/code-stubs.cc index d96694cc53..dacd5256dc 100644 --- a/src/code-stubs.cc +++ b/src/code-stubs.cc @@ -193,8 +193,8 @@ void BinaryOpStub::Generate(MacroAssembler* masm) { case BinaryOpIC::INT32: GenerateInt32Stub(masm); break; - case BinaryOpIC::HEAP_NUMBER: - GenerateHeapNumberStub(masm); + case BinaryOpIC::NUMBER: + GenerateNumberStub(masm); break; case BinaryOpIC::ODDBALL: GenerateOddballStub(masm); @@ -364,8 +364,8 @@ void ICCompareStub::Generate(MacroAssembler* masm) { case CompareIC::SMI: GenerateSmis(masm); break; - case CompareIC::HEAP_NUMBER: - GenerateHeapNumbers(masm); + case CompareIC::NUMBER: + GenerateNumbers(masm); break; case CompareIC::STRING: GenerateStrings(masm); @@ -376,7 +376,7 @@ void ICCompareStub::Generate(MacroAssembler* masm) { case CompareIC::OBJECT: GenerateObjects(masm); break; - case CompareIC::KNOWN_OBJECTS: + case CompareIC::KNOWN_OBJECT: ASSERT(*known_map_ != NULL); GenerateKnownObjects(masm); break; diff --git a/src/code-stubs.h b/src/code-stubs.h index cd90b70e90..06e28368a2 100644 --- a/src/code-stubs.h +++ b/src/code-stubs.h @@ -736,7 +736,7 @@ class BinaryOpStub: public PlatformCodeStub { void GenerateBothStringStub(MacroAssembler* masm); void GenerateGeneric(MacroAssembler* masm); void GenerateGenericStub(MacroAssembler* masm); - void GenerateHeapNumberStub(MacroAssembler* masm); + void GenerateNumberStub(MacroAssembler* masm); void GenerateInt32Stub(MacroAssembler* masm); void GenerateLoadArguments(MacroAssembler* masm); void GenerateOddballStub(MacroAssembler* masm); @@ -808,7 +808,7 @@ class ICCompareStub: public PlatformCodeStub { virtual int GetCodeKind() { return Code::COMPARE_IC; } void GenerateSmis(MacroAssembler* masm); - void GenerateHeapNumbers(MacroAssembler* masm); + void GenerateNumbers(MacroAssembler* masm); void GenerateSymbols(MacroAssembler* masm); void GenerateStrings(MacroAssembler* masm); void GenerateObjects(MacroAssembler* masm); @@ -821,7 +821,7 @@ class ICCompareStub: public PlatformCodeStub { virtual void AddToSpecialCache(Handle new_object); virtual bool FindCodeInSpecialCache(Code** code_out, Isolate* isolate); - virtual bool UseSpecialCache() { return state_ == CompareIC::KNOWN_OBJECTS; } + virtual bool UseSpecialCache() { return state_ == CompareIC::KNOWN_OBJECT; } Token::Value op_; CompareIC::State left_; diff --git a/src/ia32/code-stubs-ia32.cc b/src/ia32/code-stubs-ia32.cc index 20cc9950dc..f753fb8082 100644 --- a/src/ia32/code-stubs-ia32.cc +++ b/src/ia32/code-stubs-ia32.cc @@ -915,8 +915,8 @@ void UnaryOpStub::Generate(MacroAssembler* masm) { case UnaryOpIC::SMI: GenerateSmiStub(masm); break; - case UnaryOpIC::HEAP_NUMBER: - GenerateHeapNumberStub(masm); + case UnaryOpIC::NUMBER: + GenerateNumberStub(masm); break; case UnaryOpIC::GENERIC: GenerateGenericStub(masm); @@ -1020,13 +1020,13 @@ void UnaryOpStub::GenerateSmiCodeUndo(MacroAssembler* masm) { // TODO(svenpanne): Use virtual functions instead of switch. -void UnaryOpStub::GenerateHeapNumberStub(MacroAssembler* masm) { +void UnaryOpStub::GenerateNumberStub(MacroAssembler* masm) { switch (op_) { case Token::SUB: - GenerateHeapNumberStubSub(masm); + GenerateNumberStubSub(masm); break; case Token::BIT_NOT: - GenerateHeapNumberStubBitNot(masm); + GenerateNumberStubBitNot(masm); break; default: UNREACHABLE(); @@ -1034,7 +1034,7 @@ void UnaryOpStub::GenerateHeapNumberStub(MacroAssembler* masm) { } -void UnaryOpStub::GenerateHeapNumberStubSub(MacroAssembler* masm) { +void UnaryOpStub::GenerateNumberStubSub(MacroAssembler* masm) { Label non_smi, undo, slow, call_builtin; GenerateSmiCodeSub(masm, &non_smi, &undo, &call_builtin, Label::kNear); __ bind(&non_smi); @@ -1048,7 +1048,7 @@ void UnaryOpStub::GenerateHeapNumberStubSub(MacroAssembler* masm) { } -void UnaryOpStub::GenerateHeapNumberStubBitNot( +void UnaryOpStub::GenerateNumberStubBitNot( MacroAssembler* masm) { Label non_smi, slow; GenerateSmiCodeBitNot(masm, &non_smi, Label::kNear); @@ -1943,11 +1943,11 @@ void BinaryOpStub::GenerateOddballStub(MacroAssembler* masm) { } __ bind(&done); - GenerateHeapNumberStub(masm); + GenerateNumberStub(masm); } -void BinaryOpStub::GenerateHeapNumberStub(MacroAssembler* masm) { +void BinaryOpStub::GenerateNumberStub(MacroAssembler* masm) { Label call_runtime; // Floating point case. @@ -4429,7 +4429,7 @@ static void CheckInputType(MacroAssembler* masm, Label ok; if (expected == CompareIC::SMI) { __ JumpIfNotSmi(input, fail); - } else if (expected == CompareIC::HEAP_NUMBER) { + } else if (expected == CompareIC::NUMBER) { __ JumpIfSmi(input, &ok); __ cmp(FieldOperand(input, HeapObject::kMapOffset), Immediate(masm->isolate()->factory()->heap_number_map())); @@ -6740,8 +6740,8 @@ void ICCompareStub::GenerateSmis(MacroAssembler* masm) { } -void ICCompareStub::GenerateHeapNumbers(MacroAssembler* masm) { - ASSERT(state_ == CompareIC::HEAP_NUMBER); +void ICCompareStub::GenerateNumbers(MacroAssembler* masm) { + ASSERT(state_ == CompareIC::NUMBER); Label generic_stub; Label unordered, maybe_undefined1, maybe_undefined2; diff --git a/src/ia32/code-stubs-ia32.h b/src/ia32/code-stubs-ia32.h index 00736e1fac..bbb1df448d 100644 --- a/src/ia32/code-stubs-ia32.h +++ b/src/ia32/code-stubs-ia32.h @@ -131,9 +131,9 @@ class UnaryOpStub: public PlatformCodeStub { Label::Distance non_smi_near = Label::kFar); void GenerateSmiCodeUndo(MacroAssembler* masm); - void GenerateHeapNumberStub(MacroAssembler* masm); - void GenerateHeapNumberStubSub(MacroAssembler* masm); - void GenerateHeapNumberStubBitNot(MacroAssembler* masm); + void GenerateNumberStub(MacroAssembler* masm); + void GenerateNumberStubSub(MacroAssembler* masm); + void GenerateNumberStubBitNot(MacroAssembler* masm); void GenerateHeapNumberCodeSub(MacroAssembler* masm, Label* slow); void GenerateHeapNumberCodeBitNot(MacroAssembler* masm, Label* slow); diff --git a/src/ic.cc b/src/ic.cc index c15b76fcea..b31ea9ab8f 100644 --- a/src/ic.cc +++ b/src/ic.cc @@ -399,7 +399,7 @@ void CompareIC::Clear(Address address, Code* target) { ICCompareStub::DecodeMinorKey(target->stub_info(), NULL, NULL, &handler_state, &op); // Only clear CompareICs that can retain objects. - if (handler_state != KNOWN_OBJECTS) return; + if (handler_state != KNOWN_OBJECT) return; SetTargetAtAddress(address, GetRawUninitialized(op)); PatchInlinedSmiCode(address, DISABLE_INLINED_SMI_CHECK); } @@ -2042,7 +2042,7 @@ const char* UnaryOpIC::GetName(TypeInfo type_info) { switch (type_info) { case UNINITIALIZED: return "Uninitialized"; case SMI: return "Smi"; - case HEAP_NUMBER: return "HeapNumbers"; + case NUMBER: return "Number"; case GENERIC: return "Generic"; default: return "Invalid"; } @@ -2054,7 +2054,7 @@ UnaryOpIC::State UnaryOpIC::ToState(TypeInfo type_info) { case UNINITIALIZED: return ::v8::internal::UNINITIALIZED; case SMI: - case HEAP_NUMBER: + case NUMBER: return MONOMORPHIC; case GENERIC: return ::v8::internal::GENERIC; @@ -2069,7 +2069,7 @@ UnaryOpIC::TypeInfo UnaryOpIC::GetTypeInfo(Handle operand) { if (operand_type.IsSmi()) { return SMI; } else if (operand_type.IsNumber()) { - return HEAP_NUMBER; + return NUMBER; } else { return GENERIC; } @@ -2077,24 +2077,22 @@ UnaryOpIC::TypeInfo UnaryOpIC::GetTypeInfo(Handle operand) { UnaryOpIC::TypeInfo UnaryOpIC::ComputeNewType( - UnaryOpIC::TypeInfo current_type, - UnaryOpIC::TypeInfo previous_type) { + TypeInfo current_type, + TypeInfo previous_type) { switch (previous_type) { - case UnaryOpIC::UNINITIALIZED: + case UNINITIALIZED: return current_type; - case UnaryOpIC::SMI: - return (current_type == UnaryOpIC::GENERIC) - ? UnaryOpIC::GENERIC - : UnaryOpIC::HEAP_NUMBER; - case UnaryOpIC::HEAP_NUMBER: - return UnaryOpIC::GENERIC; - case UnaryOpIC::GENERIC: + case SMI: + return (current_type == GENERIC) ? GENERIC : NUMBER; + case NUMBER: + return GENERIC; + case GENERIC: // We should never do patching if we are in GENERIC state. UNREACHABLE(); - return UnaryOpIC::GENERIC; + return GENERIC; } UNREACHABLE(); - return UnaryOpIC::GENERIC; + return GENERIC; } @@ -2106,9 +2104,9 @@ void BinaryOpIC::patch(Code* code) { const char* BinaryOpIC::GetName(TypeInfo type_info) { switch (type_info) { case UNINITIALIZED: return "Uninitialized"; - case SMI: return "SMI"; + case SMI: return "Smi"; case INT32: return "Int32"; - case HEAP_NUMBER: return "HeapNumber"; + case NUMBER: return "Number"; case ODDBALL: return "Oddball"; case STRING: return "String"; case GENERIC: return "Generic"; @@ -2123,7 +2121,7 @@ BinaryOpIC::State BinaryOpIC::ToState(TypeInfo type_info) { return ::v8::internal::UNINITIALIZED; case SMI: case INT32: - case HEAP_NUMBER: + case NUMBER: case ODDBALL: case STRING: return MONOMORPHIC; @@ -2199,7 +2197,7 @@ static BinaryOpIC::TypeInfo TypeInfoFromValue(Handle value, if (kSmiValueSize == 32) return BinaryOpIC::SMI; return BinaryOpIC::INT32; } - if (type.IsNumber()) return BinaryOpIC::HEAP_NUMBER; + if (type.IsNumber()) return BinaryOpIC::NUMBER; if (type.IsString()) return BinaryOpIC::STRING; if (value->IsUndefined()) { if (op == Token::BIT_AND || @@ -2263,7 +2261,7 @@ RUNTIME_FUNCTION(MaybeObject*, BinaryOp_Patch) { // That is the only way to get here from the Smi stub. // With 32-bit Smis, all overflows give heap numbers, but with // 31-bit Smis, most operations overflow to int32 results. - result_type = BinaryOpIC::HEAP_NUMBER; + result_type = BinaryOpIC::NUMBER; } else { // Other operations on SMIs that overflow yield int32s. result_type = BinaryOpIC::INT32; @@ -2272,7 +2270,7 @@ RUNTIME_FUNCTION(MaybeObject*, BinaryOp_Patch) { if (new_overall == BinaryOpIC::INT32 && previous_overall == BinaryOpIC::INT32) { if (new_left == previous_left && new_right == previous_right) { - result_type = BinaryOpIC::HEAP_NUMBER; + result_type = BinaryOpIC::NUMBER; } } @@ -2377,11 +2375,11 @@ const char* CompareIC::GetStateName(State state) { switch (state) { case UNINITIALIZED: return "UNINITIALIZED"; case SMI: return "SMI"; - case HEAP_NUMBER: return "HEAP_NUMBER"; - case OBJECT: return "OBJECTS"; - case KNOWN_OBJECTS: return "KNOWN_OBJECTS"; + case NUMBER: return "NUMBER"; case SYMBOL: return "SYMBOL"; case STRING: return "STRING"; + case OBJECT: return "OBJECT"; + case KNOWN_OBJECT: return "KNOWN_OBJECT"; case GENERIC: return "GENERIC"; default: UNREACHABLE(); @@ -2395,17 +2393,17 @@ static CompareIC::State InputState(CompareIC::State old_state, switch (old_state) { case CompareIC::UNINITIALIZED: if (value->IsSmi()) return CompareIC::SMI; - if (value->IsHeapNumber()) return CompareIC::HEAP_NUMBER; + if (value->IsHeapNumber()) return CompareIC::NUMBER; if (value->IsSymbol()) return CompareIC::SYMBOL; if (value->IsString()) return CompareIC::STRING; if (value->IsJSObject()) return CompareIC::OBJECT; break; case CompareIC::SMI: if (value->IsSmi()) return CompareIC::SMI; - if (value->IsHeapNumber()) return CompareIC::HEAP_NUMBER; + if (value->IsHeapNumber()) return CompareIC::NUMBER; break; - case CompareIC::HEAP_NUMBER: - if (value->IsNumber()) return CompareIC::HEAP_NUMBER; + case CompareIC::NUMBER: + if (value->IsNumber()) return CompareIC::NUMBER; break; case CompareIC::SYMBOL: if (value->IsSymbol()) return CompareIC::SYMBOL; @@ -2419,7 +2417,7 @@ static CompareIC::State InputState(CompareIC::State old_state, break; case CompareIC::GENERIC: break; - case CompareIC::KNOWN_OBJECTS: + case CompareIC::KNOWN_OBJECT: UNREACHABLE(); break; } @@ -2436,13 +2434,13 @@ CompareIC::State CompareIC::TargetState(State old_state, switch (old_state) { case UNINITIALIZED: if (x->IsSmi() && y->IsSmi()) return SMI; - if (x->IsNumber() && y->IsNumber()) return HEAP_NUMBER; + if (x->IsNumber() && y->IsNumber()) return NUMBER; if (Token::IsOrderedRelationalCompareOp(op_)) { // Ordered comparisons treat undefined as NaN, so the - // HEAP_NUMBER stub will do the right thing. + // NUMBER stub will do the right thing. if ((x->IsNumber() && y->IsUndefined()) || (y->IsNumber() && x->IsUndefined())) { - return HEAP_NUMBER; + return NUMBER; } } if (x->IsSymbol() && y->IsSymbol()) { @@ -2454,27 +2452,31 @@ CompareIC::State CompareIC::TargetState(State old_state, if (!Token::IsEqualityOp(op_)) return GENERIC; if (x->IsJSObject() && y->IsJSObject()) { if (Handle::cast(x)->map() == - Handle::cast(y)->map() && - Token::IsEqualityOp(op_)) { - return KNOWN_OBJECTS; + Handle::cast(y)->map()) { + return KNOWN_OBJECT; } else { return OBJECT; } } return GENERIC; case SMI: - return x->IsNumber() && y->IsNumber() - ? HEAP_NUMBER - : GENERIC; + return x->IsNumber() && y->IsNumber() ? NUMBER : GENERIC; case SYMBOL: ASSERT(Token::IsEqualityOp(op_)); return x->IsString() && y->IsString() ? STRING : GENERIC; - case HEAP_NUMBER: - if (old_left == SMI && x->IsHeapNumber()) return HEAP_NUMBER; - if (old_right == SMI && y->IsHeapNumber()) return HEAP_NUMBER; + case NUMBER: + // If the failure was due to one side changing from smi to heap number, + // then keep the state (if other changed at the same time, we will get + // a second miss and then go to generic). + if (old_left == SMI && x->IsHeapNumber()) return NUMBER; + if (old_right == SMI && y->IsHeapNumber()) return NUMBER; + return GENERIC; + case KNOWN_OBJECT: + ASSERT(Token::IsEqualityOp(op_)); + if (x->IsJSObject() && y->IsJSObject()) return OBJECT; + return GENERIC; case STRING: case OBJECT: - case KNOWN_OBJECTS: case GENERIC: return GENERIC; } @@ -2493,7 +2495,7 @@ void CompareIC::UpdateCaches(Handle x, Handle y) { State state = TargetState(previous_state, previous_left, previous_right, HasInlinedSmiCode(address()), x, y); ICCompareStub stub(op_, new_left, new_right, state); - if (state == KNOWN_OBJECTS) { + if (state == KNOWN_OBJECT) { stub.set_known_map(Handle(Handle::cast(x)->map())); } set_target(*stub.GetCode(isolate())); diff --git a/src/ic.h b/src/ic.h index cbc3ce14de..f7ebdf2261 100644 --- a/src/ic.h +++ b/src/ic.h @@ -709,7 +709,7 @@ class UnaryOpIC: public IC { enum TypeInfo { UNINITIALIZED, SMI, - HEAP_NUMBER, + NUMBER, GENERIC }; @@ -734,7 +734,7 @@ class BinaryOpIC: public IC { UNINITIALIZED, SMI, INT32, - HEAP_NUMBER, + NUMBER, ODDBALL, STRING, // Only used for addition operation. GENERIC @@ -752,14 +752,20 @@ class BinaryOpIC: public IC { class CompareIC: public IC { public: + // The type/state lattice is defined by the following inequations: + // UNINITIALIZED < ... + // ... < GENERIC + // SMI < NUMBER + // SYMBOL < STRING + // KNOWN_OBJECT < OBJECT enum State { UNINITIALIZED, SMI, - HEAP_NUMBER, + NUMBER, SYMBOL, STRING, - OBJECT, - KNOWN_OBJECTS, + OBJECT, // JSObject + KNOWN_OBJECT, // JSObject with specific map (faster check) GENERIC }; diff --git a/src/mips/code-stubs-mips.h b/src/mips/code-stubs-mips.h index 7171db6865..ac0b0ff380 100644 --- a/src/mips/code-stubs-mips.h +++ b/src/mips/code-stubs-mips.h @@ -120,9 +120,9 @@ class UnaryOpStub: public PlatformCodeStub { void GenerateSmiCodeSub(MacroAssembler* masm, Label* non_smi, Label* slow); void GenerateSmiCodeBitNot(MacroAssembler* masm, Label* slow); - void GenerateHeapNumberStub(MacroAssembler* masm); - void GenerateHeapNumberStubSub(MacroAssembler* masm); - void GenerateHeapNumberStubBitNot(MacroAssembler* masm); + void GenerateNumberStub(MacroAssembler* masm); + void GenerateNumberStubSub(MacroAssembler* masm); + void GenerateNumberStubBitNot(MacroAssembler* masm); void GenerateHeapNumberCodeSub(MacroAssembler* masm, Label* slow); void GenerateHeapNumberCodeBitNot(MacroAssembler* masm, Label* slow); diff --git a/src/objects.cc b/src/objects.cc index e77ff7c32b..3a825ec78f 100644 --- a/src/objects.cc +++ b/src/objects.cc @@ -8744,7 +8744,7 @@ void Code::ClearTypeFeedbackCells(Heap* heap) { bool Code::allowed_in_shared_map_code_cache() { return is_keyed_load_stub() || is_keyed_store_stub() || (is_compare_ic_stub() && - ICCompareStub::CompareState(stub_info()) == CompareIC::KNOWN_OBJECTS); + ICCompareStub::CompareState(stub_info()) == CompareIC::KNOWN_OBJECT); } diff --git a/src/type-info.cc b/src/type-info.cc index 1acd8c63b1..b2d5917273 100644 --- a/src/type-info.cc +++ b/src/type-info.cc @@ -319,14 +319,14 @@ static TypeInfo TypeFromCompareType(CompareIC::State state) { return TypeInfo::Uninitialized(); case CompareIC::SMI: return TypeInfo::Smi(); - case CompareIC::HEAP_NUMBER: + case CompareIC::NUMBER: return TypeInfo::Number(); case CompareIC::SYMBOL: return TypeInfo::Symbol(); case CompareIC::STRING: return TypeInfo::String(); case CompareIC::OBJECT: - case CompareIC::KNOWN_OBJECTS: + case CompareIC::KNOWN_OBJECT: // TODO(kasperl): We really need a type for JS objects here. return TypeInfo::NonPrimitive(); case CompareIC::GENERIC: @@ -368,7 +368,7 @@ Handle TypeFeedbackOracle::GetCompareMap(CompareOperation* expr) { Handle code = Handle::cast(object); if (!code->is_compare_ic_stub()) return Handle::null(); CompareIC::State state = ICCompareStub::CompareState(code->stub_info()); - if (state != CompareIC::KNOWN_OBJECTS) { + if (state != CompareIC::KNOWN_OBJECT) { return Handle::null(); } Map* first_map = code->FindFirstMap(); @@ -390,7 +390,7 @@ TypeInfo TypeFeedbackOracle::UnaryType(UnaryOperation* expr) { switch (type) { case UnaryOpIC::SMI: return TypeInfo::Smi(); - case UnaryOpIC::HEAP_NUMBER: + case UnaryOpIC::NUMBER: return TypeInfo::Double(); default: return unknown; @@ -404,7 +404,7 @@ static TypeInfo TypeFromBinaryOpType(BinaryOpIC::TypeInfo binary_type) { case BinaryOpIC::UNINITIALIZED: return TypeInfo::Uninitialized(); case BinaryOpIC::SMI: return TypeInfo::Smi(); case BinaryOpIC::INT32: return TypeInfo::Integer32(); - case BinaryOpIC::HEAP_NUMBER: return TypeInfo::Double(); + case BinaryOpIC::NUMBER: return TypeInfo::Double(); case BinaryOpIC::ODDBALL: return TypeInfo::Unknown(); case BinaryOpIC::STRING: return TypeInfo::String(); case BinaryOpIC::GENERIC: return TypeInfo::Unknown(); @@ -471,7 +471,7 @@ TypeInfo TypeFeedbackOracle::IncrementType(CountOperation* expr) { return TypeInfo::Smi(); case BinaryOpIC::INT32: return TypeInfo::Integer32(); - case BinaryOpIC::HEAP_NUMBER: + case BinaryOpIC::NUMBER: return TypeInfo::Double(); case BinaryOpIC::STRING: case BinaryOpIC::GENERIC: diff --git a/src/x64/code-stubs-x64.cc b/src/x64/code-stubs-x64.cc index f5fdc5d8d4..20799787a3 100644 --- a/src/x64/code-stubs-x64.cc +++ b/src/x64/code-stubs-x64.cc @@ -775,8 +775,8 @@ void UnaryOpStub::Generate(MacroAssembler* masm) { case UnaryOpIC::SMI: GenerateSmiStub(masm); break; - case UnaryOpIC::HEAP_NUMBER: - GenerateHeapNumberStub(masm); + case UnaryOpIC::NUMBER: + GenerateNumberStub(masm); break; case UnaryOpIC::GENERIC: GenerateGenericStub(masm); @@ -857,13 +857,13 @@ void UnaryOpStub::GenerateSmiCodeBitNot(MacroAssembler* masm, // TODO(svenpanne): Use virtual functions instead of switch. -void UnaryOpStub::GenerateHeapNumberStub(MacroAssembler* masm) { +void UnaryOpStub::GenerateNumberStub(MacroAssembler* masm) { switch (op_) { case Token::SUB: - GenerateHeapNumberStubSub(masm); + GenerateNumberStubSub(masm); break; case Token::BIT_NOT: - GenerateHeapNumberStubBitNot(masm); + GenerateNumberStubBitNot(masm); break; default: UNREACHABLE(); @@ -871,7 +871,7 @@ void UnaryOpStub::GenerateHeapNumberStub(MacroAssembler* masm) { } -void UnaryOpStub::GenerateHeapNumberStubSub(MacroAssembler* masm) { +void UnaryOpStub::GenerateNumberStubSub(MacroAssembler* masm) { Label non_smi, slow, call_builtin; GenerateSmiCodeSub(masm, &non_smi, &call_builtin, Label::kNear); __ bind(&non_smi); @@ -883,7 +883,7 @@ void UnaryOpStub::GenerateHeapNumberStubSub(MacroAssembler* masm) { } -void UnaryOpStub::GenerateHeapNumberStubBitNot( +void UnaryOpStub::GenerateNumberStubBitNot( MacroAssembler* masm) { Label non_smi, slow; GenerateSmiCodeBitNot(masm, &non_smi, Label::kNear); @@ -1435,7 +1435,7 @@ void BinaryOpStub::GenerateOddballStub(MacroAssembler* masm) { } __ bind(&done); - GenerateHeapNumberStub(masm); + GenerateNumberStub(masm); } @@ -1463,7 +1463,7 @@ static void BinaryOpStub_CheckSmiInput(MacroAssembler* masm, } -void BinaryOpStub::GenerateHeapNumberStub(MacroAssembler* masm) { +void BinaryOpStub::GenerateNumberStub(MacroAssembler* masm) { Label gc_required, not_number; // It could be that only SMIs have been seen at either the left @@ -3552,7 +3552,7 @@ static void CheckInputType(MacroAssembler* masm, Label ok; if (expected == CompareIC::SMI) { __ JumpIfNotSmi(input, fail); - } else if (expected == CompareIC::HEAP_NUMBER) { + } else if (expected == CompareIC::NUMBER) { __ JumpIfSmi(input, &ok); __ CompareMap(input, masm->isolate()->factory()->heap_number_map(), NULL); __ j(not_equal, fail); @@ -5754,8 +5754,8 @@ void ICCompareStub::GenerateSmis(MacroAssembler* masm) { } -void ICCompareStub::GenerateHeapNumbers(MacroAssembler* masm) { - ASSERT(state_ == CompareIC::HEAP_NUMBER); +void ICCompareStub::GenerateNumbers(MacroAssembler* masm) { + ASSERT(state_ == CompareIC::NUMBER); Label generic_stub; Label unordered, maybe_undefined1, maybe_undefined2; diff --git a/src/x64/code-stubs-x64.h b/src/x64/code-stubs-x64.h index dab1feaed0..83861a2a0f 100644 --- a/src/x64/code-stubs-x64.h +++ b/src/x64/code-stubs-x64.h @@ -127,9 +127,9 @@ class UnaryOpStub: public PlatformCodeStub { Label* non_smi, Label::Distance non_smi_near); - void GenerateHeapNumberStub(MacroAssembler* masm); - void GenerateHeapNumberStubSub(MacroAssembler* masm); - void GenerateHeapNumberStubBitNot(MacroAssembler* masm); + void GenerateNumberStub(MacroAssembler* masm); + void GenerateNumberStubSub(MacroAssembler* masm); + void GenerateNumberStubBitNot(MacroAssembler* masm); void GenerateHeapNumberCodeSub(MacroAssembler* masm, Label* slow); void GenerateHeapNumberCodeBitNot(MacroAssembler* masm, Label* slow);