Merged r17441 into 3.20 branch. Cherrypick of V8 3.20 r17658. Fix uint32-to-smi conversion in Lithium BUG=chromium:309623 R=ulan@chromium.org Review URL: https://codereview.chromium.org/70333002 Bug: 11684308 Change-Id: I6887c0c74faac0681bf19ffd1e4d8888de5c1bfe git-svn-id: http://v8.googlecode.com/svn/branches/3.20@17658 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
diff --git a/src/arm/lithium-arm.cc b/src/arm/lithium-arm.cc index fe299ab..3df47a9 100644 --- a/src/arm/lithium-arm.cc +++ b/src/arm/lithium-arm.cc
@@ -1971,8 +1971,9 @@ } else if (to.IsSmi()) { HValue* val = instr->value(); LOperand* value = UseRegister(val); - LInstruction* result = - DefineSameAsFirst(new(zone()) LInteger32ToSmi(value)); + LInstruction* result = val->CheckFlag(HInstruction::kUint32) + ? DefineSameAsFirst(new(zone()) LUint32ToSmi(value)) + : DefineSameAsFirst(new(zone()) LInteger32ToSmi(value)); if (val->HasRange() && val->range()->IsInSmiRange()) { return result; }
diff --git a/src/arm/lithium-arm.h b/src/arm/lithium-arm.h index d81dc0f..c727fa7 100644 --- a/src/arm/lithium-arm.h +++ b/src/arm/lithium-arm.h
@@ -184,6 +184,7 @@ V(Typeof) \ V(TypeofIsAndBranch) \ V(Uint32ToDouble) \ + V(Uint32ToSmi) \ V(UnknownOSRValue) \ V(ValueOf) \ V(WrapReceiver) @@ -1987,6 +1988,19 @@ }; +class LUint32ToSmi: public LTemplateInstruction<1, 1, 0> { + public: + explicit LUint32ToSmi(LOperand* value) { + inputs_[0] = value; + } + + LOperand* value() { return inputs_[0]; } + + DECLARE_CONCRETE_INSTRUCTION(Uint32ToSmi, "uint32-to-smi") + DECLARE_HYDROGEN_ACCESSOR(Change) +}; + + class LNumberTagI: public LTemplateInstruction<1, 1, 0> { public: explicit LNumberTagI(LOperand* value) {
diff --git a/src/arm/lithium-codegen-arm.cc b/src/arm/lithium-codegen-arm.cc index 12fce43..7a943dd 100644 --- a/src/arm/lithium-codegen-arm.cc +++ b/src/arm/lithium-codegen-arm.cc
@@ -4639,9 +4639,7 @@ void LCodeGen::DoInteger32ToSmi(LInteger32ToSmi* instr) { LOperand* input = instr->value(); - ASSERT(input->IsRegister()); LOperand* output = instr->result(); - ASSERT(output->IsRegister()); __ SmiTag(ToRegister(output), ToRegister(input), SetCC); if (!instr->hydrogen()->value()->HasRange() || !instr->hydrogen()->value()->range()->IsInSmiRange()) { @@ -4660,6 +4658,18 @@ } +void LCodeGen::DoUint32ToSmi(LUint32ToSmi* instr) { + LOperand* input = instr->value(); + LOperand* output = instr->result(); + if (!instr->hydrogen()->value()->HasRange() || + !instr->hydrogen()->value()->range()->IsInSmiRange()) { + __ tst(ToRegister(input), Operand(0xc0000000)); + DeoptimizeIf(ne, instr->environment()); + } + __ SmiTag(ToRegister(output), ToRegister(input)); +} + + void LCodeGen::DoNumberTagI(LNumberTagI* instr) { class DeferredNumberTagI: public LDeferredCode { public:
diff --git a/src/hydrogen-uint32-analysis.cc b/src/hydrogen-uint32-analysis.cc index 835a198..8de887d 100644 --- a/src/hydrogen-uint32-analysis.cc +++ b/src/hydrogen-uint32-analysis.cc
@@ -35,8 +35,17 @@ // Operations that operate on bits are safe. if (use->IsBitwise() || use->IsShl() || use->IsSar() || use->IsShr()) { return true; - } else if (use->IsChange() || use->IsSimulate()) { - // Conversions and deoptimization have special support for unt32. + } else if (use->IsSimulate()) { + // Deoptimization has special support for uint32. + return true; + } else if (use->IsChange()) { + // Conversions have special support for uint32. + // This ASSERT guards that the conversion in question is actually + // implemented. Do not extend the whitelist without adding + // support to LChunkBuilder::DoChange(). + ASSERT(HChange::cast(use)->to().IsDouble() || + HChange::cast(use)->to().IsSmi() || + HChange::cast(use)->to().IsTagged()); return true; } else if (use->IsStoreKeyed()) { HStoreKeyed* store = HStoreKeyed::cast(use);
diff --git a/src/ia32/lithium-codegen-ia32.cc b/src/ia32/lithium-codegen-ia32.cc index a6c1f5a..349c2fa 100644 --- a/src/ia32/lithium-codegen-ia32.cc +++ b/src/ia32/lithium-codegen-ia32.cc
@@ -4906,6 +4906,17 @@ } +void LCodeGen::DoUint32ToSmi(LUint32ToSmi* instr) { + Register input = ToRegister(instr->value()); + if (!instr->hydrogen()->value()->HasRange() || + !instr->hydrogen()->value()->range()->IsInSmiRange()) { + __ test(input, Immediate(0xc0000000)); + DeoptimizeIf(not_zero, instr->environment()); + } + __ SmiTag(input); +} + + void LCodeGen::DoNumberTagI(LNumberTagI* instr) { class DeferredNumberTagI: public LDeferredCode { public:
diff --git a/src/ia32/lithium-ia32.cc b/src/ia32/lithium-ia32.cc index c93c3cf..7e7c63a 100644 --- a/src/ia32/lithium-ia32.cc +++ b/src/ia32/lithium-ia32.cc
@@ -1997,8 +1997,9 @@ } else if (to.IsSmi()) { HValue* val = instr->value(); LOperand* value = UseRegister(val); - LInstruction* result = - DefineSameAsFirst(new(zone()) LInteger32ToSmi(value)); + LInstruction* result = val->CheckFlag(HInstruction::kUint32) + ? DefineSameAsFirst(new(zone()) LUint32ToSmi(value)) + : DefineSameAsFirst(new(zone()) LInteger32ToSmi(value)); if (val->HasRange() && val->range()->IsInSmiRange()) { return result; }
diff --git a/src/ia32/lithium-ia32.h b/src/ia32/lithium-ia32.h index 7ae87a0..aa92935 100644 --- a/src/ia32/lithium-ia32.h +++ b/src/ia32/lithium-ia32.h
@@ -183,6 +183,7 @@ V(Typeof) \ V(TypeofIsAndBranch) \ V(Uint32ToDouble) \ + V(Uint32ToSmi) \ V(UnknownOSRValue) \ V(ValueOf) \ V(WrapReceiver) @@ -2050,6 +2051,19 @@ }; +class LUint32ToSmi: public LTemplateInstruction<1, 1, 0> { + public: + explicit LUint32ToSmi(LOperand* value) { + inputs_[0] = value; + } + + LOperand* value() { return inputs_[0]; } + + DECLARE_CONCRETE_INSTRUCTION(Uint32ToSmi, "uint32-to-smi") + DECLARE_HYDROGEN_ACCESSOR(Change) +}; + + class LNumberTagI: public LTemplateInstruction<1, 1, 0> { public: explicit LNumberTagI(LOperand* value) {
diff --git a/src/version.cc b/src/version.cc index 61089d6..ea47945 100644 --- a/src/version.cc +++ b/src/version.cc
@@ -35,7 +35,7 @@ #define MAJOR_VERSION 3 #define MINOR_VERSION 20 #define BUILD_NUMBER 17 -#define PATCH_LEVEL 16 +#define PATCH_LEVEL 17 // Use 1 for candidates and 0 otherwise. // (Boolean macro values are not supported by all preprocessors.) #define IS_CANDIDATE_VERSION 0
diff --git a/src/x64/lithium-codegen-x64.cc b/src/x64/lithium-codegen-x64.cc index 4fbcbcd..9c8446c 100644 --- a/src/x64/lithium-codegen-x64.cc +++ b/src/x64/lithium-codegen-x64.cc
@@ -4459,6 +4459,22 @@ } +void LCodeGen::DoUint32ToSmi(LUint32ToSmi* instr) { + LOperand* input = instr->value(); + ASSERT(input->IsRegister()); + LOperand* output = instr->result(); + if (!instr->hydrogen()->value()->HasRange() || + !instr->hydrogen()->value()->range()->IsInSmiRange() || + instr->hydrogen()->value()->range()->upper() == kMaxInt) { + // The Range class can't express upper bounds in the (kMaxInt, kMaxUint32] + // interval, so we treat kMaxInt as a sentinel for this entire interval. + __ testl(ToRegister(input), Immediate(0x80000000)); + DeoptimizeIf(not_zero, instr->environment()); + } + __ Integer32ToSmi(ToRegister(output), ToRegister(input)); +} + + void LCodeGen::DoNumberTagI(LNumberTagI* instr) { LOperand* input = instr->value(); ASSERT(input->IsRegister() && input->Equals(instr->result()));
diff --git a/src/x64/lithium-x64.cc b/src/x64/lithium-x64.cc index ce5d50c..e05a4c6 100644 --- a/src/x64/lithium-x64.cc +++ b/src/x64/lithium-x64.cc
@@ -1873,10 +1873,18 @@ } else if (to.IsSmi()) { HValue* val = instr->value(); LOperand* value = UseRegister(val); - LInstruction* result = - DefineAsRegister(new(zone()) LInteger32ToSmi(value)); - if (val->HasRange() && val->range()->IsInSmiRange()) { - return result; + LInstruction* result = NULL; + if (val->CheckFlag(HInstruction::kUint32)) { + result = DefineAsRegister(new(zone()) LUint32ToSmi(value)); + if (val->HasRange() && val->range()->IsInSmiRange() && + val->range()->upper() != kMaxInt) { + return result; + } + } else { + result = DefineAsRegister(new(zone()) LInteger32ToSmi(value)); + if (val->HasRange() && val->range()->IsInSmiRange()) { + return result; + } } return AssignEnvironment(result); } else {
diff --git a/src/x64/lithium-x64.h b/src/x64/lithium-x64.h index 77bebe6..b3cb682 100644 --- a/src/x64/lithium-x64.h +++ b/src/x64/lithium-x64.h
@@ -181,6 +181,7 @@ V(Typeof) \ V(TypeofIsAndBranch) \ V(Uint32ToDouble) \ + V(Uint32ToSmi) \ V(UnknownOSRValue) \ V(ValueOf) \ V(WrapReceiver) @@ -1919,6 +1920,19 @@ }; +class LUint32ToSmi: public LTemplateInstruction<1, 1, 0> { + public: + explicit LUint32ToSmi(LOperand* value) { + inputs_[0] = value; + } + + LOperand* value() { return inputs_[0]; } + + DECLARE_CONCRETE_INSTRUCTION(Uint32ToSmi, "uint32-to-smi") + DECLARE_HYDROGEN_ACCESSOR(Change) +}; + + class LNumberTagI: public LTemplateInstruction<1, 1, 0> { public: explicit LNumberTagI(LOperand* value) {
diff --git a/test/mjsunit/regress/regress-crbug-309623.js b/test/mjsunit/regress/regress-crbug-309623.js new file mode 100644 index 0000000..12473c7 --- /dev/null +++ b/test/mjsunit/regress/regress-crbug-309623.js
@@ -0,0 +1,46 @@ +// Copyright 2013 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --allow-natives-syntax + +var u = new Uint32Array(2); +u[0] = 1; +u[1] = 0xEE6B2800; + +var a = [0, 1, 2]; +a[0] = 0; // Kill the COW. +assertTrue(%HasFastSmiElements(a)); + +function foo(i) { + a[0] = u[i]; + return a[0]; +} + +assertEquals(u[0], foo(0)); +assertEquals(u[0], foo(0)); +%OptimizeFunctionOnNextCall(foo); +assertEquals(u[1], foo(1));