From: ager@chromium.org Date: Fri, 19 Mar 2010 12:26:45 +0000 (+0000) Subject: Port number-dictionary probing in generated code to x64. X-Git-Tag: upstream/4.7.83~22198 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=1bf60267e720d7574fa5cbe740aac9a5c6efba8e;p=platform%2Fupstream%2Fv8.git Port number-dictionary probing in generated code to x64. BUG=640 Review URL: http://codereview.chromium.org/1113001 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@4192 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- diff --git a/src/x64/assembler-x64.cc b/src/x64/assembler-x64.cc index a994f45..cedb740 100644 --- a/src/x64/assembler-x64.cc +++ b/src/x64/assembler-x64.cc @@ -1030,6 +1030,22 @@ void Assembler::imull(Register dst, Register src) { } +void Assembler::imull(Register dst, Register src, Immediate imm) { + EnsureSpace ensure_space(this); + last_pc_ = pc_; + emit_optional_rex_32(dst, src); + if (is_int8(imm.value_)) { + emit(0x6B); + emit_modrm(dst, src); + emit(imm.value_); + } else { + emit(0x69); + emit_modrm(dst, src); + emitl(imm.value_); + } +} + + void Assembler::incq(Register dst) { EnsureSpace ensure_space(this); last_pc_ = pc_; @@ -1190,6 +1206,15 @@ void Assembler::lea(Register dst, const Operand& src) { } +void Assembler::leal(Register dst, const Operand& src) { + EnsureSpace ensure_space(this); + last_pc_ = pc_; + emit_optional_rex_32(dst, src); + emit(0x8D); + emit_operand(dst, src); +} + + void Assembler::load_rax(void* value, RelocInfo::Mode mode) { EnsureSpace ensure_space(this); last_pc_ = pc_; @@ -1219,6 +1244,7 @@ void Assembler::movb(Register dst, const Operand& src) { emit_operand(dst, src); } + void Assembler::movb(Register dst, Immediate imm) { EnsureSpace ensure_space(this); last_pc_ = pc_; @@ -1228,6 +1254,7 @@ void Assembler::movb(Register dst, Immediate imm) { emit(imm.value_); } + void Assembler::movb(const Operand& dst, Register src) { EnsureSpace ensure_space(this); last_pc_ = pc_; @@ -1236,6 +1263,7 @@ void Assembler::movb(const Operand& dst, Register src) { emit_operand(src, dst); } + void Assembler::movw(const Operand& dst, Register src) { EnsureSpace ensure_space(this); last_pc_ = pc_; @@ -1245,6 +1273,7 @@ void Assembler::movw(const Operand& dst, Register src) { emit_operand(src, dst); } + void Assembler::movl(Register dst, const Operand& src) { EnsureSpace ensure_space(this); last_pc_ = pc_; @@ -1600,6 +1629,15 @@ void Assembler::not_(const Operand& dst) { } +void Assembler::notl(Register dst) { + EnsureSpace ensure_space(this); + last_pc_ = pc_; + emit_optional_rex_32(dst); + emit(0xF7); + emit_modrm(0x2, dst); +} + + void Assembler::nop(int n) { // The recommended muti-byte sequences of NOP instructions from the Intel 64 // and IA-32 Architectures Software Developer's Manual. diff --git a/src/x64/assembler-x64.h b/src/x64/assembler-x64.h index 5019525..6838f48 100644 --- a/src/x64/assembler-x64.h +++ b/src/x64/assembler-x64.h @@ -742,14 +742,16 @@ class Assembler : public Malloced { void imul(Register dst, Register src); // dst = dst * src. void imul(Register dst, const Operand& src); // dst = dst * src. void imul(Register dst, Register src, Immediate imm); // dst = src * imm. - // Multiply 32 bit registers + // Signed 32-bit multiply instructions. void imull(Register dst, Register src); // dst = dst * src. + void imull(Register dst, Register src, Immediate imm); // dst = src * imm. void incq(Register dst); void incq(const Operand& dst); void incl(const Operand& dst); void lea(Register dst, const Operand& src); + void leal(Register dst, const Operand& src); // Multiply rax by src, put the result in rdx:rax. void mul(Register src); @@ -760,6 +762,7 @@ class Assembler : public Malloced { void not_(Register dst); void not_(const Operand& dst); + void notl(Register dst); void or_(Register dst, Register src) { arithmetic_op(0x0B, dst, src); diff --git a/src/x64/disasm-x64.cc b/src/x64/disasm-x64.cc index 547daee..9ba364a 100644 --- a/src/x64/disasm-x64.cc +++ b/src/x64/disasm-x64.cc @@ -1273,7 +1273,9 @@ int DisassemblerX64::InstructionDecode(v8::internal::Vector out_buffer, get_modrm(*(data + 1), &mod, ®op, &rm); int32_t imm = *data == 0x6B ? *(data + 2) : *reinterpret_cast(data + 2); - AppendToBuffer("imul %s,%s,0x%x", NameOfCPURegister(regop), + AppendToBuffer("imul%c %s,%s,0x%x", + operand_size_code(), + NameOfCPURegister(regop), NameOfCPURegister(rm), imm); data += 2 + (*data == 0x6B ? 1 : 4); break; diff --git a/src/x64/ic-x64.cc b/src/x64/ic-x64.cc index e05f68d..1d28a1f 100644 --- a/src/x64/ic-x64.cc +++ b/src/x64/ic-x64.cc @@ -151,6 +151,108 @@ static void GenerateDictionaryLoad(MacroAssembler* masm, } +static void GenerateNumberDictionaryLoad(MacroAssembler* masm, + Label* miss, + Register elements, + Register key, + Register r0, + Register r1, + Register r2) { + // Register use: + // + // elements - holds the slow-case elements of the receiver and is unchanged. + // + // key - holds the smi key on entry and is unchanged if a branch is + // performed to the miss label. + // + // Scratch registers: + // + // r0 - holds the untagged key on entry and holds the hash once computed. + // Holds the result on exit if the load succeeded. + // + // r1 - used to hold the capacity mask of the dictionary + // + // r2 - used for the index into the dictionary. + Label done; + + // Compute the hash code from the untagged key. This must be kept in sync + // with ComputeIntegerHash in utils.h. + // + // hash = ~hash + (hash << 15); + __ movl(r1, r0); + __ notl(r0); + __ shll(r1, Immediate(15)); + __ addl(r0, r1); + // hash = hash ^ (hash >> 12); + __ movl(r1, r0); + __ shrl(r1, Immediate(12)); + __ xorl(r0, r1); + // hash = hash + (hash << 2); + __ leal(r0, Operand(r0, r0, times_4, 0)); + // hash = hash ^ (hash >> 4); + __ movl(r1, r0); + __ shrl(r1, Immediate(4)); + __ xorl(r0, r1); + // hash = hash * 2057; + __ imull(r0, r0, Immediate(2057)); + // hash = hash ^ (hash >> 16); + __ movl(r1, r0); + __ shrl(r1, Immediate(16)); + __ xorl(r0, r1); + + // Compute capacity mask. + const int kCapacityOffset = + StringDictionary::kHeaderSize + + StringDictionary::kCapacityIndex * kPointerSize; + __ movq(r1, FieldOperand(elements, kCapacityOffset)); + __ SmiToInteger32(r1, r1); + __ decl(r1); + + const int kElementsStartOffset = + NumberDictionary::kHeaderSize + + NumberDictionary::kElementsStartIndex * kPointerSize; + + // Generate an unrolled loop that performs a few probes before giving up. + const int kProbes = 4; + for (int i = 0; i < kProbes; i++) { + // Use r2 for index calculations and keep the hash intact in r0. + __ movq(r2, r0); + // Compute the masked index: (hash + i + i * i) & mask. + if (i > 0) { + __ addl(r2, Immediate(NumberDictionary::GetProbeOffset(i))); + } + __ and_(r2, r1); + + // Scale the index by multiplying by the entry size. + ASSERT(NumberDictionary::kEntrySize == 3); + __ lea(r2, Operand(r2, r2, times_2, 0)); // r2 = r2 * 3 + + // Check if the key matches. + __ cmpq(key, FieldOperand(elements, + r2, + times_pointer_size, + kElementsStartOffset)); + if (i != (kProbes - 1)) { + __ j(equal, &done); + } else { + __ j(not_equal, miss); + } + } + + __ bind(&done); + // Check that the value is a normal propety. + const int kDetailsOffset = kElementsStartOffset + 2 * kPointerSize; + ASSERT_EQ(NORMAL, 0); + __ Test(FieldOperand(elements, r2, times_pointer_size, kDetailsOffset), + Smi::FromInt(PropertyDetails::TypeField::mask())); + __ j(not_zero, miss); + + // Get the value at the masked, scaled index. + const int kValueOffset = kElementsStartOffset + kPointerSize; + __ movq(r0, FieldOperand(elements, r2, times_pointer_size, kValueOffset)); +} + + // Helper function used to check that a value is either not an object // or is loaded if it is an object. static void GenerateCheckNonObjectOrLoaded(MacroAssembler* masm, Label* miss, @@ -271,6 +373,7 @@ void KeyedLoadIC::GenerateGeneric(MacroAssembler* masm) { // ----------------------------------- Label slow, check_string, index_int, index_string; Label check_pixel_array, probe_dictionary; + Label check_number_dictionary; // Load name and receiver. __ movq(rax, Operand(rsp, kPointerSize)); @@ -294,6 +397,9 @@ void KeyedLoadIC::GenerateGeneric(MacroAssembler* masm) { // Check that the key is a smi. __ JumpIfNotSmi(rax, &check_string); + // Save key in rbx in case we want it for the number dictionary + // case. + __ movq(rbx, rax); __ SmiToInteger32(rax, rax); // Get the elements array of the object. __ bind(&index_int); @@ -321,7 +427,7 @@ void KeyedLoadIC::GenerateGeneric(MacroAssembler* masm) { __ bind(&check_pixel_array); __ CompareRoot(FieldOperand(rcx, HeapObject::kMapOffset), Heap::kPixelArrayMapRootIndex); - __ j(not_equal, &slow); + __ j(not_equal, &check_number_dictionary); __ cmpl(rax, FieldOperand(rcx, PixelArray::kLengthOffset)); __ j(above_equal, &slow); __ movq(rcx, FieldOperand(rcx, PixelArray::kExternalPointerOffset)); @@ -329,6 +435,17 @@ void KeyedLoadIC::GenerateGeneric(MacroAssembler* masm) { __ Integer32ToSmi(rax, rax); __ ret(0); + __ bind(&check_number_dictionary); + // Check whether the elements is a number dictionary. + // rax: untagged index + // rbx: key + // rcx: elements + __ CompareRoot(FieldOperand(rcx, HeapObject::kMapOffset), + Heap::kHashTableMapRootIndex); + __ j(not_equal, &slow); + GenerateNumberDictionaryLoad(masm, &slow, rcx, rbx, rax, rdx, rdi); + __ ret(0); + // Slow case: Load name and receiver from stack and jump to runtime. __ bind(&slow); __ IncrementCounter(&Counters::keyed_load_generic_slow, 1);