From 44f0eee88ff00398ff7f715fab053374d808c90d Mon Sep 17 00:00:00 2001 From: Steve Block Date: Thu, 26 May 2011 01:26:41 +0100 Subject: Update V8 to r7427: Initial merge by git As required by WebKit r82507 Change-Id: I7ae83ef3f689356043b4929255b7c1dd31d8c5df --- src/ia32/lithium-ia32.cc | 134 +++++++++++++++++++++++++++++++++++------------ 1 file changed, 101 insertions(+), 33 deletions(-) (limited to 'src/ia32/lithium-ia32.cc') diff --git a/src/ia32/lithium-ia32.cc b/src/ia32/lithium-ia32.cc index 4440cdfa..199a80ae 100644 --- a/src/ia32/lithium-ia32.cc +++ b/src/ia32/lithium-ia32.cc @@ -1366,13 +1366,23 @@ LInstruction* LChunkBuilder::DoMod(HMod* instr) { if (instr->representation().IsInteger32()) { ASSERT(instr->left()->representation().IsInteger32()); ASSERT(instr->right()->representation().IsInteger32()); - // The temporary operand is necessary to ensure that right is not allocated - // into edx. - LOperand* temp = FixedTemp(edx); - LOperand* value = UseFixed(instr->left(), eax); - LOperand* divisor = UseRegister(instr->right()); - LModI* mod = new LModI(value, divisor, temp); - LInstruction* result = DefineFixed(mod, edx); + + LInstruction* result; + if (instr->HasPowerOf2Divisor()) { + ASSERT(!instr->CheckFlag(HValue::kCanBeDivByZero)); + LOperand* value = UseRegisterAtStart(instr->left()); + LModI* mod = new LModI(value, UseOrConstant(instr->right()), NULL); + result = DefineSameAsFirst(mod); + } else { + // The temporary operand is necessary to ensure that right is + // not allocated into edx. + LOperand* temp = FixedTemp(edx); + LOperand* value = UseFixed(instr->left(), eax); + LOperand* divisor = UseRegister(instr->right()); + LModI* mod = new LModI(value, divisor, temp); + result = DefineFixed(mod, edx); + } + return (instr->CheckFlag(HValue::kBailoutOnMinusZero) || instr->CheckFlag(HValue::kCanBeDivByZero)) ? AssignEnvironment(result) @@ -1577,9 +1587,10 @@ LInstruction* LChunkBuilder::DoFixedArrayLength(HFixedArrayLength* instr) { } -LInstruction* LChunkBuilder::DoPixelArrayLength(HPixelArrayLength* instr) { +LInstruction* LChunkBuilder::DoExternalArrayLength( + HExternalArrayLength* instr) { LOperand* array = UseRegisterAtStart(instr->value()); - return DefineAsRegister(new LPixelArrayLength(array)); + return DefineAsRegister(new LExternalArrayLength(array)); } @@ -1622,8 +1633,9 @@ LInstruction* LChunkBuilder::DoChange(HChange* instr) { LOperand* value = UseRegister(instr->value()); bool needs_check = !instr->value()->type().IsSmi(); if (needs_check) { + CpuFeatures* cpu_features = Isolate::Current()->cpu_features(); LOperand* xmm_temp = - (instr->CanTruncateToInt32() && CpuFeatures::IsSupported(SSE3)) + (instr->CanTruncateToInt32() && cpu_features->IsSupported(SSE3)) ? NULL : FixedTemp(xmm1); LTaggedToI* res = new LTaggedToI(value, xmm_temp); @@ -1644,7 +1656,7 @@ LInstruction* LChunkBuilder::DoChange(HChange* instr) { } else { ASSERT(to.IsInteger32()); bool needs_temp = instr->CanTruncateToInt32() && - !CpuFeatures::IsSupported(SSE3); + !Isolate::Current()->cpu_features()->IsSupported(SSE3); LOperand* value = needs_temp ? UseTempRegister(instr->value()) : UseRegister(instr->value()); LOperand* temp = needs_temp ? TempRegister() : NULL; @@ -1672,7 +1684,7 @@ LInstruction* LChunkBuilder::DoChange(HChange* instr) { LInstruction* LChunkBuilder::DoCheckNonSmi(HCheckNonSmi* instr) { LOperand* value = UseRegisterAtStart(instr->value()); - return AssignEnvironment(new LCheckSmi(value, zero)); + return AssignEnvironment(new LCheckNonSmi(value)); } @@ -1693,7 +1705,7 @@ LInstruction* LChunkBuilder::DoCheckPrototypeMaps(HCheckPrototypeMaps* instr) { LInstruction* LChunkBuilder::DoCheckSmi(HCheckSmi* instr) { LOperand* value = UseRegisterAtStart(instr->value()); - return AssignEnvironment(new LCheckSmi(value, not_zero)); + return AssignEnvironment(new LCheckSmi(value)); } @@ -1778,6 +1790,21 @@ LInstruction* LChunkBuilder::DoLoadNamedField(HLoadNamedField* instr) { } +LInstruction* LChunkBuilder::DoLoadNamedFieldPolymorphic( + HLoadNamedFieldPolymorphic* instr) { + ASSERT(instr->representation().IsTagged()); + if (instr->need_generic()) { + LOperand* obj = UseFixed(instr->object(), eax); + LLoadNamedFieldPolymorphic* result = new LLoadNamedFieldPolymorphic(obj); + return MarkAsCall(DefineFixed(result, eax), instr); + } else { + LOperand* obj = UseRegisterAtStart(instr->object()); + LLoadNamedFieldPolymorphic* result = new LLoadNamedFieldPolymorphic(obj); + return AssignEnvironment(DefineAsRegister(result)); + } +} + + LInstruction* LChunkBuilder::DoLoadNamedGeneric(HLoadNamedGeneric* instr) { LOperand* context = UseFixed(instr->context(), esi); LOperand* object = UseFixed(instr->object(), eax); @@ -1800,10 +1827,10 @@ LInstruction* LChunkBuilder::DoLoadElements(HLoadElements* instr) { } -LInstruction* LChunkBuilder::DoLoadPixelArrayExternalPointer( - HLoadPixelArrayExternalPointer* instr) { +LInstruction* LChunkBuilder::DoLoadExternalArrayPointer( + HLoadExternalArrayPointer* instr) { LOperand* input = UseRegisterAtStart(instr->value()); - return DefineAsRegister(new LLoadPixelArrayExternalPointer(input)); + return DefineAsRegister(new LLoadExternalArrayPointer(input)); } @@ -1818,16 +1845,24 @@ LInstruction* LChunkBuilder::DoLoadKeyedFastElement( } -LInstruction* LChunkBuilder::DoLoadPixelArrayElement( - HLoadPixelArrayElement* instr) { - ASSERT(instr->representation().IsInteger32()); +LInstruction* LChunkBuilder::DoLoadKeyedSpecializedArrayElement( + HLoadKeyedSpecializedArrayElement* instr) { + ExternalArrayType array_type = instr->array_type(); + Representation representation(instr->representation()); + ASSERT((representation.IsInteger32() && array_type != kExternalFloatArray) || + (representation.IsDouble() && array_type == kExternalFloatArray)); ASSERT(instr->key()->representation().IsInteger32()); - LOperand* external_pointer = - UseRegisterAtStart(instr->external_pointer()); - LOperand* key = UseRegisterAtStart(instr->key()); - LLoadPixelArrayElement* result = - new LLoadPixelArrayElement(external_pointer, key); - return DefineSameAsFirst(result); + LOperand* external_pointer = UseRegister(instr->external_pointer()); + LOperand* key = UseRegister(instr->key()); + LLoadKeyedSpecializedArrayElement* result = + new LLoadKeyedSpecializedArrayElement(external_pointer, + key); + LInstruction* load_instr = DefineAsRegister(result); + // An unsigned int array load might overflow and cause a deopt, make sure it + // has an environment. + return (array_type == kExternalUnsignedIntArray) + ? AssignEnvironment(load_instr) + : load_instr; } @@ -1860,20 +1895,39 @@ LInstruction* LChunkBuilder::DoStoreKeyedFastElement( } -LInstruction* LChunkBuilder::DoStorePixelArrayElement( - HStorePixelArrayElement* instr) { - ASSERT(instr->value()->representation().IsInteger32()); +LInstruction* LChunkBuilder::DoStoreKeyedSpecializedArrayElement( + HStoreKeyedSpecializedArrayElement* instr) { + Representation representation(instr->value()->representation()); + ExternalArrayType array_type = instr->array_type(); + ASSERT((representation.IsInteger32() && array_type != kExternalFloatArray) || + (representation.IsDouble() && array_type == kExternalFloatArray)); ASSERT(instr->external_pointer()->representation().IsExternal()); ASSERT(instr->key()->representation().IsInteger32()); LOperand* external_pointer = UseRegister(instr->external_pointer()); - LOperand* val = UseRegister(instr->value()); LOperand* key = UseRegister(instr->key()); - // The generated code requires that the clamped value is in a byte - // register. eax is an arbitrary choice to satisfy this requirement. - LOperand* clamped = FixedTemp(eax); + LOperand* temp = NULL; + + if (array_type == kExternalPixelArray) { + // The generated code for pixel array stores requires that the clamped value + // is in a byte register. eax is an arbitrary choice to satisfy this + // requirement. + temp = FixedTemp(eax); + } + + LOperand* val = NULL; + if (array_type == kExternalByteArray || + array_type == kExternalUnsignedByteArray) { + // We need a byte register in this case for the value. + val = UseFixed(instr->value(), eax); + } else { + val = UseRegister(instr->value()); + } - return new LStorePixelArrayElement(external_pointer, key, val, clamped); + return new LStoreKeyedSpecializedArrayElement(external_pointer, + key, + val, + temp); } @@ -1932,6 +1986,13 @@ LInstruction* LChunkBuilder::DoStringCharCodeAt(HStringCharCodeAt* instr) { } +LInstruction* LChunkBuilder::DoStringCharFromCode(HStringCharFromCode* instr) { + LOperand* char_code = UseRegister(instr->value()); + LStringCharFromCode* result = new LStringCharFromCode(char_code); + return AssignPointerMap(DefineAsRegister(result)); +} + + LInstruction* LChunkBuilder::DoStringLength(HStringLength* instr) { LOperand* string = UseRegisterAtStart(instr->value()); return DefineAsRegister(new LStringLength(string)); @@ -2011,6 +2072,13 @@ LInstruction* LChunkBuilder::DoAccessArgumentsAt(HAccessArgumentsAt* instr) { } +LInstruction* LChunkBuilder::DoToFastProperties(HToFastProperties* instr) { + LOperand* object = UseFixed(instr->value(), eax); + LToFastProperties* result = new LToFastProperties(object); + return MarkAsCall(DefineFixed(result, eax), instr); +} + + LInstruction* LChunkBuilder::DoTypeof(HTypeof* instr) { LTypeof* result = new LTypeof(UseAtStart(instr->value())); return MarkAsCall(DefineFixed(result, eax), instr); -- cgit v1.2.3