| Index: src/mips/lithium-codegen-mips.cc
|
| diff --git a/src/mips/lithium-codegen-mips.cc b/src/mips/lithium-codegen-mips.cc
|
| index 0d2863aad9d90498aabdcf408c5cb4d42da25473..9a081238f4d57e58df826089964187bcf59a7106 100644
|
| --- a/src/mips/lithium-codegen-mips.cc
|
| +++ b/src/mips/lithium-codegen-mips.cc
|
| @@ -3082,10 +3082,16 @@ void LCodeGen::DoLoadKeyedExternalArray(LLoadKeyed* instr) {
|
| int element_size_shift = ElementsKindToShiftSize(elements_kind);
|
| int shift_size = (instr->hydrogen()->key()->representation().IsSmi())
|
| ? (element_size_shift - kSmiTagSize) : element_size_shift;
|
| - int additional_offset = instr->additional_index() << element_size_shift;
|
| + int additional_offset = IsFixedTypedArrayElementsKind(elements_kind)
|
| + ? FixedTypedArrayBase::kDataOffset - kHeapObjectTag
|
| + : 0;
|
|
|
| if (elements_kind == EXTERNAL_FLOAT_ELEMENTS ||
|
| - elements_kind == EXTERNAL_DOUBLE_ELEMENTS) {
|
| + elements_kind == FLOAT32_ELEMENTS ||
|
| + elements_kind == EXTERNAL_DOUBLE_ELEMENTS ||
|
| + elements_kind == FLOAT64_ELEMENTS) {
|
| + int base_offset =
|
| + (instr->additional_index() << element_size_shift) + additional_offset;
|
| FPURegister result = ToDoubleRegister(instr->result());
|
| if (key_is_constant) {
|
| __ Addu(scratch0(), external_pointer, constant_key << element_size_shift);
|
| @@ -3093,11 +3099,12 @@ void LCodeGen::DoLoadKeyedExternalArray(LLoadKeyed* instr) {
|
| __ sll(scratch0(), key, shift_size);
|
| __ Addu(scratch0(), scratch0(), external_pointer);
|
| }
|
| - if (elements_kind == EXTERNAL_FLOAT_ELEMENTS) {
|
| - __ lwc1(result, MemOperand(scratch0(), additional_offset));
|
| + if (elements_kind == EXTERNAL_FLOAT_ELEMENTS ||
|
| + elements_kind == FLOAT32_ELEMENTS) {
|
| + __ lwc1(result, MemOperand(scratch0(), base_offset));
|
| __ cvt_d_s(result, result);
|
| - } else { // i.e. elements_kind == EXTERNAL_DOUBLE_ELEMENTS
|
| - __ ldc1(result, MemOperand(scratch0(), additional_offset));
|
| + } else { // loading doubles, not floats.
|
| + __ ldc1(result, MemOperand(scratch0(), base_offset));
|
| }
|
| } else {
|
| Register result = ToRegister(instr->result());
|
| @@ -3107,28 +3114,37 @@ void LCodeGen::DoLoadKeyedExternalArray(LLoadKeyed* instr) {
|
| instr->additional_index(), additional_offset);
|
| switch (elements_kind) {
|
| case EXTERNAL_BYTE_ELEMENTS:
|
| + case INT8_ELEMENTS:
|
| __ lb(result, mem_operand);
|
| break;
|
| case EXTERNAL_PIXEL_ELEMENTS:
|
| case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
|
| + case UINT8_ELEMENTS:
|
| + case UINT8_CLAMPED_ELEMENTS:
|
| __ lbu(result, mem_operand);
|
| break;
|
| case EXTERNAL_SHORT_ELEMENTS:
|
| + case INT16_ELEMENTS:
|
| __ lh(result, mem_operand);
|
| break;
|
| case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
|
| + case UINT16_ELEMENTS:
|
| __ lhu(result, mem_operand);
|
| break;
|
| case EXTERNAL_INT_ELEMENTS:
|
| + case INT32_ELEMENTS:
|
| __ lw(result, mem_operand);
|
| break;
|
| case EXTERNAL_UNSIGNED_INT_ELEMENTS:
|
| + case UINT32_ELEMENTS:
|
| __ lw(result, mem_operand);
|
| if (!instr->hydrogen()->CheckFlag(HInstruction::kUint32)) {
|
| DeoptimizeIf(Ugreater_equal, instr->environment(),
|
| result, Operand(0x80000000));
|
| }
|
| break;
|
| + case FLOAT32_ELEMENTS:
|
| + case FLOAT64_ELEMENTS:
|
| case EXTERNAL_FLOAT_ELEMENTS:
|
| case EXTERNAL_DOUBLE_ELEMENTS:
|
| case FAST_DOUBLE_ELEMENTS:
|
| @@ -3227,7 +3243,7 @@ void LCodeGen::DoLoadKeyedFixedArray(LLoadKeyed* instr) {
|
|
|
|
|
| void LCodeGen::DoLoadKeyed(LLoadKeyed* instr) {
|
| - if (instr->is_external()) {
|
| + if (instr->is_typed_elements()) {
|
| DoLoadKeyedExternalArray(instr);
|
| } else if (instr->hydrogen()->representation().IsDouble()) {
|
| DoLoadKeyedFixedDoubleArray(instr);
|
| @@ -3245,14 +3261,28 @@ MemOperand LCodeGen::PrepareKeyedOperand(Register key,
|
| int shift_size,
|
| int additional_index,
|
| int additional_offset) {
|
| - if (additional_index != 0 && !key_is_constant) {
|
| - additional_index *= 1 << (element_size - shift_size);
|
| - __ Addu(scratch0(), key, Operand(additional_index));
|
| - }
|
| -
|
| + int base_offset = (additional_index << element_size) + additional_offset;
|
| if (key_is_constant) {
|
| return MemOperand(base,
|
| - (constant_key << element_size) + additional_offset);
|
| + base_offset + (constant_key << element_size));
|
| + }
|
| +
|
| + if (additional_offset != 0) {
|
| + if (shift_size >= 0) {
|
| + __ sll(scratch0(), key, shift_size);
|
| + __ Addu(scratch0(), scratch0(), Operand(base_offset));
|
| + } else {
|
| + ASSERT_EQ(-1, shift_size);
|
| + __ srl(scratch0(), key, 1);
|
| + __ Addu(scratch0(), scratch0(), Operand(base_offset));
|
| + }
|
| + __ Addu(scratch0(), base, scratch0());
|
| + return MemOperand(scratch0());
|
| + }
|
| +
|
| + if (additional_index != 0) {
|
| + additional_index *= 1 << (element_size - shift_size);
|
| + __ Addu(scratch0(), key, Operand(additional_index));
|
| }
|
|
|
| if (additional_index == 0) {
|
| @@ -4178,10 +4208,16 @@ void LCodeGen::DoStoreKeyedExternalArray(LStoreKeyed* instr) {
|
| int element_size_shift = ElementsKindToShiftSize(elements_kind);
|
| int shift_size = (instr->hydrogen()->key()->representation().IsSmi())
|
| ? (element_size_shift - kSmiTagSize) : element_size_shift;
|
| - int additional_offset = instr->additional_index() << element_size_shift;
|
| + int additional_offset = IsFixedTypedArrayElementsKind(elements_kind)
|
| + ? FixedTypedArrayBase::kDataOffset - kHeapObjectTag
|
| + : 0;
|
|
|
| if (elements_kind == EXTERNAL_FLOAT_ELEMENTS ||
|
| - elements_kind == EXTERNAL_DOUBLE_ELEMENTS) {
|
| + elements_kind == FLOAT32_ELEMENTS ||
|
| + elements_kind == EXTERNAL_DOUBLE_ELEMENTS ||
|
| + elements_kind == FLOAT64_ELEMENTS) {
|
| + int base_offset =
|
| + (instr->additional_index() << element_size_shift) + additional_offset;
|
| Register address = scratch0();
|
| FPURegister value(ToDoubleRegister(instr->value()));
|
| if (key_is_constant) {
|
| @@ -4196,11 +4232,12 @@ void LCodeGen::DoStoreKeyedExternalArray(LStoreKeyed* instr) {
|
| __ Addu(address, external_pointer, address);
|
| }
|
|
|
| - if (elements_kind == EXTERNAL_FLOAT_ELEMENTS) {
|
| + if (elements_kind == EXTERNAL_FLOAT_ELEMENTS ||
|
| + elements_kind == FLOAT32_ELEMENTS) {
|
| __ cvt_s_d(double_scratch0(), value);
|
| - __ swc1(double_scratch0(), MemOperand(address, additional_offset));
|
| - } else { // i.e. elements_kind == EXTERNAL_DOUBLE_ELEMENTS
|
| - __ sdc1(value, MemOperand(address, additional_offset));
|
| + __ swc1(double_scratch0(), MemOperand(address, base_offset));
|
| + } else { // Storing doubles, not floats.
|
| + __ sdc1(value, MemOperand(address, base_offset));
|
| }
|
| } else {
|
| Register value(ToRegister(instr->value()));
|
| @@ -4212,16 +4249,25 @@ void LCodeGen::DoStoreKeyedExternalArray(LStoreKeyed* instr) {
|
| case EXTERNAL_PIXEL_ELEMENTS:
|
| case EXTERNAL_BYTE_ELEMENTS:
|
| case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
|
| + case UINT8_ELEMENTS:
|
| + case UINT8_CLAMPED_ELEMENTS:
|
| + case INT8_ELEMENTS:
|
| __ sb(value, mem_operand);
|
| break;
|
| case EXTERNAL_SHORT_ELEMENTS:
|
| case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
|
| + case INT16_ELEMENTS:
|
| + case UINT16_ELEMENTS:
|
| __ sh(value, mem_operand);
|
| break;
|
| case EXTERNAL_INT_ELEMENTS:
|
| case EXTERNAL_UNSIGNED_INT_ELEMENTS:
|
| + case INT32_ELEMENTS:
|
| + case UINT32_ELEMENTS:
|
| __ sw(value, mem_operand);
|
| break;
|
| + case FLOAT32_ELEMENTS:
|
| + case FLOAT64_ELEMENTS:
|
| case EXTERNAL_FLOAT_ELEMENTS:
|
| case EXTERNAL_DOUBLE_ELEMENTS:
|
| case FAST_DOUBLE_ELEMENTS:
|
| @@ -4340,7 +4386,7 @@ void LCodeGen::DoStoreKeyedFixedArray(LStoreKeyed* instr) {
|
|
|
| void LCodeGen::DoStoreKeyed(LStoreKeyed* instr) {
|
| // By cases: external, fast double
|
| - if (instr->is_external()) {
|
| + if (instr->is_typed_elements()) {
|
| DoStoreKeyedExternalArray(instr);
|
| } else if (instr->hydrogen()->value()->representation().IsDouble()) {
|
| DoStoreKeyedFixedDoubleArray(instr);
|
|
|