From 7de60ef84dadc5d53fce86e3e149444d6a0888fe Mon Sep 17 00:00:00 2001 From: "karlklose@chromium.org" Date: Wed, 16 Feb 2011 08:21:45 +0000 Subject: [PATCH] ARM: Implement GetCachedArrayIndex in the lithium code generator. Add GetCachedArrayIndex to the Hydrogen instruction set and implement GetCachedArrayIndex in the lithium code generator. The x64 and ia32 code generators implementations abort in the chunk builder. Review URL: http://codereview.chromium.org/6499014 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@6803 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/arm/lithium-arm.cc | 9 +++++++++ src/arm/lithium-arm.h | 12 ++++++++++++ src/arm/lithium-codegen-arm.cc | 20 +++++++++++++++----- src/hydrogen-instructions.h | 12 ++++++++++++ src/hydrogen.cc | 5 ++++- src/ia32/lithium-ia32.cc | 7 +++++++ src/x64/lithium-x64.cc | 7 +++++++ 7 files changed, 66 insertions(+), 6 deletions(-) diff --git a/src/arm/lithium-arm.cc b/src/arm/lithium-arm.cc index 82de5d3..903f77b 100644 --- a/src/arm/lithium-arm.cc +++ b/src/arm/lithium-arm.cc @@ -1491,6 +1491,15 @@ LInstruction* LChunkBuilder::DoHasInstanceType(HHasInstanceType* instr) { } +LInstruction* LChunkBuilder::DoGetCachedArrayIndex( + HGetCachedArrayIndex* instr) { + ASSERT(instr->value()->representation().IsTagged()); + LOperand* value = UseRegister(instr->value()); + + return DefineAsRegister(new LGetCachedArrayIndex(value)); +} + + LInstruction* LChunkBuilder::DoHasCachedArrayIndex( HHasCachedArrayIndex* instr) { ASSERT(instr->value()->representation().IsTagged()); diff --git a/src/arm/lithium-arm.h b/src/arm/lithium-arm.h index 8d2573d..57338f1 100644 --- a/src/arm/lithium-arm.h +++ b/src/arm/lithium-arm.h @@ -94,6 +94,7 @@ class LCodeGen; V(FixedArrayLength) \ V(FunctionLiteral) \ V(Gap) \ + V(GetCachedArrayIndex) \ V(GlobalObject) \ V(GlobalReceiver) \ V(Goto) \ @@ -739,6 +740,17 @@ class LHasCachedArrayIndex: public LTemplateInstruction<1, 1, 0> { }; +class LGetCachedArrayIndex: public LTemplateInstruction<1, 1, 0> { + public: + explicit LGetCachedArrayIndex(LOperand* value) { + inputs_[0] = value; + } + + DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex, "get-cached-array-index") + DECLARE_HYDROGEN_ACCESSOR(GetCachedArrayIndex) +}; + + class LHasCachedArrayIndexAndBranch: public LControlInstruction<1, 0> { public: explicit LHasCachedArrayIndexAndBranch(LOperand* value) { diff --git a/src/arm/lithium-codegen-arm.cc b/src/arm/lithium-codegen-arm.cc index 68d3f49..1bfb3ad 100644 --- a/src/arm/lithium-codegen-arm.cc +++ b/src/arm/lithium-codegen-arm.cc @@ -1896,6 +1896,16 @@ void LCodeGen::DoHasInstanceTypeAndBranch(LHasInstanceTypeAndBranch* instr) { } +void LCodeGen::DoGetCachedArrayIndex(LGetCachedArrayIndex* instr) { + Register input = ToRegister(instr->InputAt(0)); + Register result = ToRegister(instr->result()); + Register scratch = scratch0(); + + __ ldr(scratch, FieldMemOperand(input, String::kHashFieldOffset)); + __ IndexFromHash(scratch, result); +} + + void LCodeGen::DoHasCachedArrayIndex(LHasCachedArrayIndex* instr) { Register input = ToRegister(instr->InputAt(0)); Register result = ToRegister(instr->result()); @@ -1903,10 +1913,10 @@ void LCodeGen::DoHasCachedArrayIndex(LHasCachedArrayIndex* instr) { ASSERT(instr->hydrogen()->value()->representation().IsTagged()); __ ldr(scratch, - FieldMemOperand(input, String::kContainsCachedArrayIndexMask)); + FieldMemOperand(input, String::kHashFieldOffset)); __ tst(scratch, Operand(String::kContainsCachedArrayIndexMask)); - __ LoadRoot(result, Heap::kTrueValueRootIndex, ne); - __ LoadRoot(result, Heap::kFalseValueRootIndex, eq); + __ LoadRoot(result, Heap::kTrueValueRootIndex, eq); + __ LoadRoot(result, Heap::kFalseValueRootIndex, ne); } @@ -1919,9 +1929,9 @@ void LCodeGen::DoHasCachedArrayIndexAndBranch( int false_block = chunk_->LookupDestination(instr->false_block_id()); __ ldr(scratch, - FieldMemOperand(input, String::kContainsCachedArrayIndexMask)); + FieldMemOperand(input, String::kHashFieldOffset)); __ tst(scratch, Operand(String::kContainsCachedArrayIndexMask)); - EmitBranch(true_block, false_block, ne); + EmitBranch(true_block, false_block, eq); } diff --git a/src/hydrogen-instructions.h b/src/hydrogen-instructions.h index a0d932f..9f5170c 100644 --- a/src/hydrogen-instructions.h +++ b/src/hydrogen-instructions.h @@ -107,6 +107,7 @@ class LChunkBuilder; V(EnterInlined) \ V(FixedArrayLength) \ V(FunctionLiteral) \ + V(GetCachedArrayIndex) \ V(GlobalObject) \ V(GlobalReceiver) \ V(Goto) \ @@ -2331,6 +2332,17 @@ class HHasCachedArrayIndex: public HUnaryPredicate { }; +class HGetCachedArrayIndex: public HUnaryPredicate { + public: + explicit HGetCachedArrayIndex(HValue* value) : HUnaryPredicate(value) { } + + DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex, "get_cached_array_index") + + protected: + virtual bool DataEquals(HValue* other) const { return true; } +}; + + class HClassOfTest: public HUnaryPredicate { public: HClassOfTest(HValue* value, Handle class_name) diff --git a/src/hydrogen.cc b/src/hydrogen.cc index 58478e4..3ebd580 100644 --- a/src/hydrogen.cc +++ b/src/hydrogen.cc @@ -5463,7 +5463,10 @@ void HGraphBuilder::GenerateIsRegExpEquivalent(int argument_count, void HGraphBuilder::GenerateGetCachedArrayIndex(int argument_count, int ast_id) { - BAILOUT("inlined runtime function: GetCachedArrayIndex"); + ASSERT(argument_count == 1); + HValue* value = Pop(); + HGetCachedArrayIndex* result = new HGetCachedArrayIndex(value); + ast_context()->ReturnInstruction(result, ast_id); } diff --git a/src/ia32/lithium-ia32.cc b/src/ia32/lithium-ia32.cc index 0ad3819..a57e8c9 100644 --- a/src/ia32/lithium-ia32.cc +++ b/src/ia32/lithium-ia32.cc @@ -1521,6 +1521,13 @@ LInstruction* LChunkBuilder::DoHasInstanceType(HHasInstanceType* instr) { } +LInstruction* LChunkBuilder::DoGetCachedArrayIndex( + HGetCachedArrayIndex* instr) { + Abort("Unimplemented: %s", "DoGetCachedArrayIndex"); + return NULL; +} + + LInstruction* LChunkBuilder::DoHasCachedArrayIndex( HHasCachedArrayIndex* instr) { ASSERT(instr->value()->representation().IsTagged()); diff --git a/src/x64/lithium-x64.cc b/src/x64/lithium-x64.cc index a6635ad..fba29a6 100644 --- a/src/x64/lithium-x64.cc +++ b/src/x64/lithium-x64.cc @@ -1422,6 +1422,13 @@ LInstruction* LChunkBuilder::DoHasInstanceType(HHasInstanceType* instr) { } +LInstruction* LChunkBuilder::DoGetCachedArrayIndex( + HGetCachedArrayIndex* instr) { + Abort("Unimplemented: %s", "DoGetCachedArrayIndex"); + return NULL; +} + + LInstruction* LChunkBuilder::DoHasCachedArrayIndex( HHasCachedArrayIndex* instr) { Abort("Unimplemented: %s", "DoHasCachedArrayIndex"); -- 2.7.4