AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Revert "Add support to load/store byte fields." and "MIPS: Add support to load/store byte fields.".

Browse Source 
This reverts commit r17079 and r17085. Will reland after fix.

TBR=jkummerow@chromium.org

Review URL: https://codereview.chromium.org/25679008

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@17099 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
bmeurer@chromium.org 2013-10-04 05:47:35 +00:00
parent 36072e610c
commit 5e8c902991
10 changed files with 66 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
src/arm/lithium-codegen-arm.cc
View File

@ -3042,12 +3042,7 @@ void LCodeGen::DoLoadNamedField(LLoadNamedField* instr) {
if (access.IsExternalMemory()) {
Register result = ToRegister(instr->result());
MemOperand operand = MemOperand(object, offset);
if (access.representation().IsByte()) {
__ ldrb(result, operand);
} else {
__ ldr(result, operand);
}
__ ldr(result, MemOperand(object, offset));
return;
}
@ -3058,15 +3053,11 @@ void LCodeGen::DoLoadNamedField(LLoadNamedField* instr) {
}
Register result = ToRegister(instr->result());
if (!access.IsInobject()) {
__ ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
object = result;
}
MemOperand operand = FieldMemOperand(object, offset);
if (access.representation().IsByte()) {
__ ldrb(result, operand);
if (access.IsInobject()) {
__ ldr(result, FieldMemOperand(object, offset));
} else {
__ ldr(result, operand);
__ ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
__ ldr(result, FieldMemOperand(result, offset));
}
}
@ -4172,12 +4163,7 @@ void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
if (access.IsExternalMemory()) {
Register value = ToRegister(instr->value());
MemOperand operand = MemOperand(object, offset);
if (representation.IsByte()) {
__ strb(value, operand);
} else {
__ str(value, operand);
}
__ str(value, MemOperand(object, offset));
return;
}
@ -4222,12 +4208,7 @@ void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
instr->hydrogen()->value()->IsHeapObject()
? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
if (access.IsInobject()) {
MemOperand operand = FieldMemOperand(object, offset);
if (representation.IsByte()) {
__ strb(value, operand);
} else {
__ str(value, operand);
}
__ str(value, FieldMemOperand(object, offset));
if (instr->hydrogen()->NeedsWriteBarrier()) {
// Update the write barrier for the object for in-object properties.
__ RecordWriteField(object,
@ -4241,12 +4222,7 @@ void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
}
} else {
__ ldr(scratch, FieldMemOperand(object, JSObject::kPropertiesOffset));
MemOperand operand = FieldMemOperand(scratch, offset);
if (representation.IsByte()) {
__ strb(value, operand);
} else {
__ str(value, operand);
}
__ str(value, FieldMemOperand(scratch, offset));
if (instr->hydrogen()->NeedsWriteBarrier()) {
// Update the write barrier for the properties array.
// object is used as a scratch register.

3
src/hydrogen-instructions.cc
View File

@ -2829,9 +2829,6 @@ Range* HShl::InferRange(Zone* zone) {
Range* HLoadNamedField::InferRange(Zone* zone) {
if (access().representation().IsByte()) {
return new(zone) Range(0, 255);
}
if (access().IsStringLength()) {
return new(zone) Range(0, String::kMaxLength);
}

17
src/hydrogen-instructions.h
View File

@ -5954,9 +5954,7 @@ class HLoadNamedField V8_FINAL : public HTemplateInstruction<1> {
SetOperandAt(0, object);
Representation representation = access.representation();
if (representation.IsByte()) {
set_representation(Representation::Integer32());
} else if (representation.IsSmi()) {
if (representation.IsSmi()) {
set_type(HType::Smi());
set_representation(representation);
} else if (representation.IsDouble() ||
@ -6254,14 +6252,11 @@ class HStoreNamedField V8_FINAL : public HTemplateInstruction<3> {
if (index == 0 && access().IsExternalMemory()) {
// object must be external in case of external memory access
return Representation::External();
} else if (index == 1) {
if (field_representation().IsByte() ||
field_representation().IsInteger32()) {
return Representation::Integer32();
} else if (field_representation().IsDouble() ||
field_representation().IsSmi()) {
return field_representation();
}
} else if (index == 1 &&
(field_representation().IsDouble() ||
field_representation().IsSmi() ||
field_representation().IsInteger32())) {
return field_representation();
}
return Representation::Tagged();
}

54
src/ia32/lithium-codegen-ia32.cc
View File

@ -3225,15 +3225,12 @@ void LCodeGen::DoLoadNamedField(LLoadNamedField* instr) {
if (access.IsExternalMemory()) {
Register result = ToRegister(instr->result());
MemOperand operand = instr->object()->IsConstantOperand()
? MemOperand::StaticVariable(ToExternalReference(
LConstantOperand::cast(instr->object())))
: MemOperand(ToRegister(instr->object()), offset);
if (access.representation().IsByte()) {
ASSERT(instr->hydrogen()->representation().IsInteger32());
__ movzx_b(result, operand);
if (instr->object()->IsConstantOperand()) {
ExternalReference external_reference = ToExternalReference(
LConstantOperand::cast(instr->object()));
__ mov(result, MemOperand::StaticVariable(external_reference));
} else {
__ mov(result, operand);
__ mov(result, MemOperand(ToRegister(instr->object()), offset));
}
return;
}
@ -3252,15 +3249,11 @@ void LCodeGen::DoLoadNamedField(LLoadNamedField* instr) {
}
Register result = ToRegister(instr->result());
if (!access.IsInobject()) {
__ mov(result, FieldOperand(object, JSObject::kPropertiesOffset));
object = result;
}
if (access.representation().IsByte()) {
ASSERT(instr->hydrogen()->representation().IsInteger32());
__ movzx_b(result, FieldOperand(object, offset));
} else {
if (access.IsInobject()) {
__ mov(result, FieldOperand(object, offset));
} else {
__ mov(result, FieldOperand(object, JSObject::kPropertiesOffset));
__ mov(result, FieldOperand(result, offset));
}
}
@ -4436,18 +4429,10 @@ void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
: MemOperand(ToRegister(instr->object()), offset);
if (instr->value()->IsConstantOperand()) {
LConstantOperand* operand_value = LConstantOperand::cast(instr->value());
if (representation.IsByte()) {
__ mov_b(operand, ToInteger32(operand_value));
} else {
__ mov(operand, Immediate(ToInteger32(operand_value)));
}
__ mov(operand, Immediate(ToInteger32(operand_value)));
} else {
Register value = ToRegister(instr->value());
if (representation.IsByte()) {
__ mov_b(operand, value);
} else {
__ mov(operand, value);
}
__ mov(operand, value);
}
return;
}
@ -4520,28 +4505,17 @@ void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
__ mov(write_register, FieldOperand(object, JSObject::kPropertiesOffset));
}
MemOperand operand = FieldOperand(write_register, offset);
if (instr->value()->IsConstantOperand()) {
LConstantOperand* operand_value = LConstantOperand::cast(instr->value());
if (operand_value->IsRegister()) {
Register value = ToRegister(operand_value);
if (representation.IsByte()) {
__ mov_b(operand, value);
} else {
__ mov(operand, value);
}
__ mov(FieldOperand(write_register, offset), ToRegister(operand_value));
} else {
Handle<Object> handle_value = ToHandle(operand_value);
ASSERT(!instr->hydrogen()->NeedsWriteBarrier());
__ mov(operand, handle_value);
__ mov(FieldOperand(write_register, offset), handle_value);
}
} else {
Register value = ToRegister(instr->value());
if (representation.IsByte()) {
__ mov_b(operand, value);
} else {
__ mov(operand, value);
}
__ mov(FieldOperand(write_register, offset), ToRegister(instr->value()));
}
if (instr->hydrogen()->NeedsWriteBarrier()) {

40
src/mips/lithium-codegen-mips.cc
View File

@ -2896,12 +2896,7 @@ void LCodeGen::DoLoadNamedField(LLoadNamedField* instr) {
if (access.IsExternalMemory()) {
Register result = ToRegister(instr->result());
MemOperand operand = MemOperand(object, offset);
if (access.representation().IsByte()) {
__ lb(result, operand);
} else {
__ lw(result, operand);
}
__ lw(result, MemOperand(object, offset));
return;
}
@ -2912,15 +2907,11 @@ void LCodeGen::DoLoadNamedField(LLoadNamedField* instr) {
}
Register result = ToRegister(instr->result());
if (!access.IsInobject()) {
__ lw(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
object = result;
}
MemOperand operand = FieldMemOperand(object, offset);
if (access.representation().IsByte()) {
__ lb(result, operand);
if (access.IsInobject()) {
__ lw(result, FieldMemOperand(object, offset));
} else {
__ lw(result, operand);
__ lw(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
__ lw(result, FieldMemOperand(result, offset));
}
}
@ -4084,12 +4075,7 @@ void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
if (access.IsExternalMemory()) {
Register value = ToRegister(instr->value());
MemOperand operand = MemOperand(object, offset);
if (representation.IsByte()) {
__ sb(value, operand);
} else {
__ sw(value, operand);
}
__ sw(value, MemOperand(object, offset));
return;
}
@ -4134,12 +4120,7 @@ void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
instr->hydrogen()->value()->IsHeapObject()
? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
if (access.IsInobject()) {
MemOperand operand = FieldMemOperand(object, offset);
if (representation.IsByte()) {
__ sb(value, operand);
} else {
__ sw(value, operand);
}
__ sw(value, FieldMemOperand(object, offset));
if (instr->hydrogen()->NeedsWriteBarrier()) {
// Update the write barrier for the object for in-object properties.
__ RecordWriteField(object,
@ -4153,12 +4134,7 @@ void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
}
} else {
__ lw(scratch, FieldMemOperand(object, JSObject::kPropertiesOffset));
MemOperand operand = FieldMemOperand(scratch, offset);
if (representation.IsByte()) {
__ sb(value, operand);
} else {
__ sw(value, operand);
}
__ sw(value, FieldMemOperand(scratch, offset));
if (instr->hydrogen()->NeedsWriteBarrier()) {
// Update the write barrier for the properties array.
// object is used as a scratch register.

5
src/property-details.h
View File

@ -82,7 +82,6 @@ class Representation {
public:
enum Kind {
kNone,
kByte,
kSmi,
kInteger32,
kDouble,
@ -96,7 +95,6 @@ class Representation {
static Representation None() { return Representation(kNone); }
static Representation Tagged() { return Representation(kTagged); }
static Representation Byte() { return Representation(kByte); }
static Representation Smi() { return Representation(kSmi); }
static Representation Integer32() { return Representation(kInteger32); }
static Representation Double() { return Representation(kDouble); }
@ -141,7 +139,6 @@ class Representation {
Kind kind() const { return static_cast<Kind>(kind_); }
bool IsNone() const { return kind_ == kNone; }
bool IsByte() const { return kind_ == kByte; }
bool IsTagged() const { return kind_ == kTagged; }
bool IsSmi() const { return kind_ == kSmi; }
bool IsSmiOrTagged() const { return IsSmi() || IsTagged(); }
@ -151,7 +148,7 @@ class Representation {
bool IsHeapObject() const { return kind_ == kHeapObject; }
bool IsExternal() const { return kind_ == kExternal; }
bool IsSpecialization() const {
return IsByte() || IsSmi() || IsInteger32() || IsDouble();
return kind_ == kInteger32 || kind_ == kDouble || kind_ == kSmi;
}
const char* Mnemonic() const;

38
src/x64/lithium-codegen-x64.cc
View File

@ -2725,13 +2725,14 @@ void LCodeGen::DoLoadNamedField(LLoadNamedField* instr) {
int offset = access.offset();
if (access.IsExternalMemory()) {
ASSERT(!access.representation().IsInteger32());
Register result = ToRegister(instr->result());
if (instr->object()->IsConstantOperand()) {
ASSERT(result.is(rax));
__ load_rax(ToExternalReference(LConstantOperand::cast(instr->object())));
} else {
Register object = ToRegister(instr->object());
__ Load(result, MemOperand(object, offset), access.representation());
__ movq(result, MemOperand(object, offset));
}
return;
}
@ -2745,11 +2746,20 @@ void LCodeGen::DoLoadNamedField(LLoadNamedField* instr) {
}
Register result = ToRegister(instr->result());
if (!access.IsInobject()) {
if (access.IsInobject()) {
if (access.representation().IsInteger32()) {
__ movl(result, FieldOperand(object, offset));
} else {
__ movq(result, FieldOperand(object, offset));
}
} else {
__ movq(result, FieldOperand(object, JSObject::kPropertiesOffset));
object = result;
if (access.representation().IsInteger32()) {
__ movl(result, FieldOperand(result, offset));
} else {
__ movq(result, FieldOperand(result, offset));
}
}
__ Load(result, FieldOperand(object, offset), access.representation());
}
@ -3871,16 +3881,16 @@ void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
int offset = access.offset();
if (access.IsExternalMemory()) {
ASSERT(!access.representation().IsInteger32());
ASSERT(!instr->hydrogen()->NeedsWriteBarrier());
Register value = ToRegister(instr->value());
if (instr->object()->IsConstantOperand()) {
ASSERT(value.is(rax));
ASSERT(!access.representation().IsSpecialization());
LConstantOperand* object = LConstantOperand::cast(instr->object());
__ store_rax(ToExternalReference(object));
} else {
Register object = ToRegister(instr->object());
__ Store(MemOperand(object, offset), value, representation);
__ movq(MemOperand(object, offset), value);
}
return;
}
@ -3949,16 +3959,24 @@ void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
if (instr->value()->IsConstantOperand()) {
LConstantOperand* operand_value = LConstantOperand::cast(instr->value());
if (operand_value->IsRegister()) {
Register value = ToRegister(operand_value);
__ Store(FieldOperand(write_register, offset), value, representation);
if (access.representation().IsInteger32()) {
__ movl(FieldOperand(write_register, offset),
ToRegister(operand_value));
} else {
__ movq(FieldOperand(write_register, offset),
ToRegister(operand_value));
}
} else {
Handle<Object> handle_value = ToHandle(operand_value);
ASSERT(!instr->hydrogen()->NeedsWriteBarrier());
__ Move(FieldOperand(write_register, offset), handle_value);
}
} else {
Register value = ToRegister(instr->value());
__ Store(FieldOperand(write_register, offset), value, representation);
if (access.representation().IsInteger32()) {
__ movl(FieldOperand(write_register, offset), ToRegister(instr->value()));
} else {
__ movq(FieldOperand(write_register, offset), ToRegister(instr->value()));
}
}
if (instr->hydrogen()->NeedsWriteBarrier()) {

9
src/x64/lithium-x64.cc
View File

@ -2060,14 +2060,7 @@ LInstruction* LChunkBuilder::DoStoreContextSlot(HStoreContextSlot* instr) {
LInstruction* LChunkBuilder::DoLoadNamedField(HLoadNamedField* instr) {
// Use the special mov rax, moffs64 encoding for external
// memory accesses with 64-bit word-sized values.
if (instr->access().IsExternalMemory() &&
instr->access().offset() == 0 &&
(instr->access().representation().IsSmi() ||
instr->access().representation().IsTagged() ||
instr->access().representation().IsHeapObject() ||
instr->access().representation().IsExternal())) {
if (instr->access().IsExternalMemory() && instr->access().offset() == 0) {
LOperand* obj = UseRegisterOrConstantAtStart(instr->object());
return DefineFixed(new(zone()) LLoadNamedField(obj), rax);
}

22
src/x64/macro-assembler-x64.cc
View File

@ -947,28 +947,6 @@ void MacroAssembler::Cvtlsi2sd(XMMRegister dst, const Operand& src) {
}
void MacroAssembler::Load(Register dst, const Operand& src, Representation r) {
if (r.IsByte()) {
movzxbl(dst, src);
} else if (r.IsInteger32()) {
movl(dst, src);
} else {
movq(dst, src);
}
}
void MacroAssembler::Store(const Operand& dst, Register src, Representation r) {
if (r.IsByte()) {
movb(dst, src);
} else if (r.IsInteger32()) {
movl(dst, src);
} else {
movq(dst, src);
}
}
void MacroAssembler::Set(Register dst, int64_t x) {
if (x == 0) {
xorl(dst, dst);

4
src/x64/macro-assembler-x64.h
View File

@ -781,10 +781,6 @@ class MacroAssembler: public Assembler {
// ---------------------------------------------------------------------------
// Macro instructions.
// Load/store with specific representation.
void Load(Register dst, const Operand& src, Representation r);
void Store(const Operand& dst, Register src, Representation r);
// Load a register with a long value as efficiently as possible.
void Set(Register dst, int64_t x);
void Set(const Operand& dst, int64_t x);