Revision: 14163
Author: [email protected]
Date: Mon Apr 8 05:23:09 2013
Log: Merged r14124, r14131 into 3.17 branch.
Ensure UseRegisterAtStart not used with fixed temp/return register
MIPS: Ensure UseRegisterAtStart not used with fixed temp/return register
BUG=chromium:201590
[email protected]
Review URL: https://codereview.chromium.org/13527010
http://code.google.com/p/v8/source/detail?r=14163
Added:
/branches/3.17/test/mjsunit/regress/regress-201590.js
Modified:
/branches/3.17/src/arm/lithium-arm.cc
/branches/3.17/src/ia32/lithium-ia32.cc
/branches/3.17/src/mips/lithium-mips.cc
/branches/3.17/src/version.cc
/branches/3.17/src/x64/lithium-x64.cc
=======================================
--- /dev/null
+++ /branches/3.17/test/mjsunit/regress/regress-201590.js Mon Apr 8
05:23:09 2013
@@ -0,0 +1,66 @@
+// 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 gdpRatio = 16/9;
+
+function Foo(initialX, initialY, initialScale, initialMapHeight) {
+ this.ORIGIN = { x: initialX, y: initialY };
+ this.scale = initialScale;
+ this.mapHeight = initialMapHeight;
+}
+
+Foo.prototype.bar = function (x, y, xOffset, yOffset) {
+ var tileHeight = 64 * 0.25 * this.scale,
+ tileWidth = 128 * 0.25 * this.scale,
+ xOffset = xOffset * 0.5 || 0,
+ yOffset = yOffset * 0.5 || 0;
+ var xPos = ((xOffset) * gdpRatio) + this.ORIGIN.x * this.scale -
+ ((y * tileWidth ) * gdpRatio) + ((x * tileWidth ) * gdpRatio);
+ var yPos = ((yOffset) * gdpRatio) + this.ORIGIN.y * this.scale +
+ ((y * tileHeight) * gdpRatio) + ((x * tileHeight) * gdpRatio);
+ xPos = xPos - Math.round(((tileWidth) * gdpRatio)) +
+ this.mapHeight * Math.round(((tileWidth) * gdpRatio));
+ return {
+ x: Math.floor(xPos),
+ y: Math.floor(yPos)
+ };
+}
+
+var f = new Foo(10, 20, 2.5, 400);
+
+function baz() {
+ var b = f.bar(1.1, 2.2, 3.3, 4.4);
+ assertEquals(56529, b.x);
+ assertEquals(288, b.y);
+}
+
+baz();
+baz();
+%OptimizeFunctionOnNextCall(Foo.prototype.bar);
+baz();
=======================================
--- /branches/3.17/src/arm/lithium-arm.cc Thu Feb 28 07:55:26 2013
+++ /branches/3.17/src/arm/lithium-arm.cc Mon Apr 8 05:23:09 2013
@@ -849,6 +849,35 @@
LInstruction* instr = current->CompileToLithium(this);
if (instr != NULL) {
+#if DEBUG
+ // Make sure that the lithium instruction has either no fixed register
+ // constraints in temps or the result OR no uses that are only used at
+ // start. If this invariant doesn't hold, the register allocator can
decide
+ // to insert a split of a range immediately before the instruction due
to an
+ // already allocated register needing to be used for the instruction's
fixed
+ // register constraint. In this case, The register allocator won't see
an
+ // interference between the split child and the use-at-start (it would
if
+ // the it was just a plain use), so it is free to move the split child
into
+ // the same register that is used for the use-at-start.
+ // See https://code.google.com/p/chromium/issues/detail?id=201590
+ if (!(instr->ClobbersRegisters() && instr->ClobbersDoubleRegisters()))
{
+ int fixed = 0;
+ int used_at_start = 0;
+ for (UseIterator it(instr); !it.Done(); it.Advance()) {
+ LUnallocated* operand = LUnallocated::cast(it.Current());
+ if (operand->IsUsedAtStart()) ++used_at_start;
+ }
+ if (instr->Output() != NULL) {
+ if (LUnallocated::cast(instr->Output())->HasFixedPolicy()) ++fixed;
+ }
+ for (TempIterator it(instr); !it.Done(); it.Advance()) {
+ LUnallocated* operand = LUnallocated::cast(it.Current());
+ if (operand->HasFixedPolicy()) ++fixed;
+ }
+ ASSERT(fixed == 0 || used_at_start == 0);
+ }
+#endif
+
if (FLAG_stress_pointer_maps && !instr->HasPointerMap()) {
instr = AssignPointerMap(instr);
}
@@ -1084,7 +1113,7 @@
LUnaryMathOperation* result = new(zone()) LUnaryMathOperation(input,
temp);
return DefineFixedDouble(result, d2);
} else {
- LOperand* input = UseRegisterAtStart(instr->value());
+ LOperand* input = UseRegister(instr->value());
LOperand* temp = (op == kMathRound) ? FixedTemp(d3) : NULL;
LUnaryMathOperation* result = new(zone()) LUnaryMathOperation(input,
temp);
@@ -1770,11 +1799,13 @@
return AssignEnvironment(DefineAsRegister(res));
} else {
ASSERT(to.IsInteger32());
- LOperand* value = UseRegisterAtStart(instr->value());
+ LOperand* value = NULL;
LInstruction* res = NULL;
if (instr->value()->type().IsSmi()) {
+ value = UseRegisterAtStart(instr->value());
res = DefineAsRegister(new(zone()) LSmiUntag(value, false));
} else {
+ value = UseRegister(instr->value());
LOperand* temp1 = TempRegister();
LOperand* temp2 = instr->CanTruncateToInt32() ? TempRegister()
: NULL;
=======================================
--- /branches/3.17/src/ia32/lithium-ia32.cc Thu Feb 28 07:55:26 2013
+++ /branches/3.17/src/ia32/lithium-ia32.cc Mon Apr 8 05:23:09 2013
@@ -895,6 +895,35 @@
LInstruction* instr = current->CompileToLithium(this);
if (instr != NULL) {
+#if DEBUG
+ // Make sure that the lithium instruction has either no fixed register
+ // constraints in temps or the result OR no uses that are only used at
+ // start. If this invariant doesn't hold, the register allocator can
decide
+ // to insert a split of a range immediately before the instruction due
to an
+ // already allocated register needing to be used for the instruction's
fixed
+ // register constraint. In this case, The register allocator won't see
an
+ // interference between the split child and the use-at-start (it would
if
+ // the it was just a plain use), so it is free to move the split child
into
+ // the same register that is used for the use-at-start.
+ // See https://code.google.com/p/chromium/issues/detail?id=201590
+ if (!(instr->ClobbersRegisters() && instr->ClobbersDoubleRegisters()))
{
+ int fixed = 0;
+ int used_at_start = 0;
+ for (UseIterator it(instr); !it.Done(); it.Advance()) {
+ LUnallocated* operand = LUnallocated::cast(it.Current());
+ if (operand->IsUsedAtStart()) ++used_at_start;
+ }
+ if (instr->Output() != NULL) {
+ if (LUnallocated::cast(instr->Output())->HasFixedPolicy()) ++fixed;
+ }
+ for (TempIterator it(instr); !it.Done(); it.Advance()) {
+ LUnallocated* operand = LUnallocated::cast(it.Current());
+ if (operand->HasFixedPolicy()) ++fixed;
+ }
+ ASSERT(fixed == 0 || used_at_start == 0);
+ }
+#endif
+
if (FLAG_stress_pointer_maps && !instr->HasPointerMap()) {
instr = AssignPointerMap(instr);
}
=======================================
--- /branches/3.17/src/mips/lithium-mips.cc Thu Feb 21 06:06:02 2013
+++ /branches/3.17/src/mips/lithium-mips.cc Mon Apr 8 05:23:09 2013
@@ -849,6 +849,35 @@
LInstruction* instr = current->CompileToLithium(this);
if (instr != NULL) {
+#if DEBUG
+ // Make sure that the lithium instruction has either no fixed register
+ // constraints in temps or the result OR no uses that are only used at
+ // start. If this invariant doesn't hold, the register allocator can
decide
+ // to insert a split of a range immediately before the instruction due
to an
+ // already allocated register needing to be used for the instruction's
fixed
+ // register constraint. In this case, The register allocator won't see
an
+ // interference between the split child and the use-at-start (it would
if
+ // the it was just a plain use), so it is free to move the split child
into
+ // the same register that is used for the use-at-start.
+ // See https://code.google.com/p/chromium/issues/detail?id=201590
+ if (!(instr->ClobbersRegisters() && instr->ClobbersDoubleRegisters()))
{
+ int fixed = 0;
+ int used_at_start = 0;
+ for (UseIterator it(instr); !it.Done(); it.Advance()) {
+ LUnallocated* operand = LUnallocated::cast(it.Current());
+ if (operand->IsUsedAtStart()) ++used_at_start;
+ }
+ if (instr->Output() != NULL) {
+ if (LUnallocated::cast(instr->Output())->HasFixedPolicy()) ++fixed;
+ }
+ for (TempIterator it(instr); !it.Done(); it.Advance()) {
+ LUnallocated* operand = LUnallocated::cast(it.Current());
+ if (operand->HasFixedPolicy()) ++fixed;
+ }
+ ASSERT(fixed == 0 || used_at_start == 0);
+ }
+#endif
+
if (FLAG_stress_pointer_maps && !instr->HasPointerMap()) {
instr = AssignPointerMap(instr);
}
@@ -1079,7 +1108,7 @@
LUnaryMathOperation* result = new(zone()) LUnaryMathOperation(input,
temp);
return DefineFixedDouble(result, f4);
} else {
- LOperand* input = UseRegisterAtStart(instr->value());
+ LOperand* input = UseRegister(instr->value());
LOperand* temp = (op == kMathRound) ? FixedTemp(f6) :
(op == kMathFloor) ? TempRegister() : NULL;
@@ -1645,11 +1674,13 @@
return AssignEnvironment(DefineAsRegister(res));
} else {
ASSERT(to.IsInteger32());
- LOperand* value = UseRegisterAtStart(instr->value());
+ LOperand* value = NULL;
LInstruction* res = NULL;
if (instr->value()->type().IsSmi()) {
+ value = UseRegisterAtStart(instr->value());
res = DefineAsRegister(new(zone()) LSmiUntag(value, false));
} else {
+ value = UseRegister(instr->value());
LOperand* temp1 = TempRegister();
LOperand* temp2 = instr->CanTruncateToInt32() ? TempRegister()
: NULL;
=======================================
--- /branches/3.17/src/version.cc Tue Apr 2 02:50:22 2013
+++ /branches/3.17/src/version.cc Mon Apr 8 05:23:09 2013
@@ -35,7 +35,7 @@
#define MAJOR_VERSION 3
#define MINOR_VERSION 17
#define BUILD_NUMBER 6
-#define PATCH_LEVEL 2
+#define PATCH_LEVEL 3
// Use 1 for candidates and 0 otherwise.
// (Boolean macro values are not supported by all preprocessors.)
#define IS_CANDIDATE_VERSION 0
=======================================
--- /branches/3.17/src/x64/lithium-x64.cc Thu Feb 28 07:55:26 2013
+++ /branches/3.17/src/x64/lithium-x64.cc Mon Apr 8 05:23:09 2013
@@ -857,6 +857,35 @@
LInstruction* instr = current->CompileToLithium(this);
if (instr != NULL) {
+#if DEBUG
+ // Make sure that the lithium instruction has either no fixed register
+ // constraints in temps or the result OR no uses that are only used at
+ // start. If this invariant doesn't hold, the register allocator can
decide
+ // to insert a split of a range immediately before the instruction due
to an
+ // already allocated register needing to be used for the instruction's
fixed
+ // register constraint. In this case, The register allocator won't see
an
+ // interference between the split child and the use-at-start (it would
if
+ // the it was just a plain use), so it is free to move the split child
into
+ // the same register that is used for the use-at-start.
+ // See https://code.google.com/p/chromium/issues/detail?id=201590
+ if (!(instr->ClobbersRegisters() && instr->ClobbersDoubleRegisters()))
{
+ int fixed = 0;
+ int used_at_start = 0;
+ for (UseIterator it(instr); !it.Done(); it.Advance()) {
+ LUnallocated* operand = LUnallocated::cast(it.Current());
+ if (operand->IsUsedAtStart()) ++used_at_start;
+ }
+ if (instr->Output() != NULL) {
+ if (LUnallocated::cast(instr->Output())->HasFixedPolicy()) ++fixed;
+ }
+ for (TempIterator it(instr); !it.Done(); it.Advance()) {
+ LUnallocated* operand = LUnallocated::cast(it.Current());
+ if (operand->HasFixedPolicy()) ++fixed;
+ }
+ ASSERT(fixed == 0 || used_at_start == 0);
+ }
+#endif
+
if (FLAG_stress_pointer_maps && !instr->HasPointerMap()) {
instr = AssignPointerMap(instr);
}
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/groups/opt_out.
