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

Reland "ARM64: Add overflow checking support for multiplications by constant powers of 2."

Browse Source 
This includes fixes for the overflow case spotted in mjsunit/mul-exhaustive-part4.

R=ulan@chromium.org

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

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20267 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
alexandre.rames@arm.com 2014-03-26 10:11:01 +00:00
parent c6bff48f09
commit f921ef399c
2 changed files with 51 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/arm64/lithium-arm64.cc
View File

@ -1891,29 +1891,36 @@ LInstruction* LChunkBuilder::DoMul(HMul* instr) {
HValue* least_const = instr->BetterLeftOperand();
HValue* most_const = instr->BetterRightOperand();
LOperand* left = UseRegisterAtStart(least_const);
LOperand* left;
// LMulConstI can handle a subset of constants:
// With support for overflow detection:
// -1, 0, 1, 2
// Without support for overflow detection:
// 2^n, -(2^n)
// Without support for overflow detection:
// 2^n + 1, -(2^n - 1)
if (most_const->IsConstant()) {
int32_t constant = HConstant::cast(most_const)->Integer32Value();
int32_t constant_abs = (constant >= 0) ? constant : -constant;
bool small_constant = (constant >= -1) && (constant <= 2);
bool end_range_constant = (constant <= -kMaxInt) || (constant == kMaxInt);
int32_t constant_abs = Abs(constant);
if (((constant >= -1) && (constant <= 2)) ||
(!can_overflow && (IsPowerOf2(constant_abs) ||
IsPowerOf2(constant_abs + 1) ||
IsPowerOf2(constant_abs - 1)))) {
if (!end_range_constant &&
(small_constant ||
(IsPowerOf2(constant_abs)) ||
(!can_overflow && (IsPowerOf2(constant_abs + 1) ||
IsPowerOf2(constant_abs - 1))))) {
LConstantOperand* right = UseConstant(most_const);
bool need_register = IsPowerOf2(constant_abs) && !small_constant;
left = need_register ? UseRegister(least_const)
: UseRegisterAtStart(least_const);
LMulConstIS* mul = new(zone()) LMulConstIS(left, right);
if (needs_environment) AssignEnvironment(mul);
return DefineAsRegister(mul);
}
}
left = UseRegisterAtStart(least_const);
// LMulI/S can handle all cases, but it requires that a register is
// allocated for the second operand.
LInstruction* result;

52
src/arm64/lithium-codegen-arm64.cc
View File

@ -4253,6 +4253,7 @@ void LCodeGen::DoMulConstIS(LMulConstIS* instr) {
Register left =
is_smi ? ToRegister(instr->left()) : ToRegister32(instr->left()) ;
int32_t right = ToInteger32(instr->right());
ASSERT((right > -kMaxInt) || (right < kMaxInt));
bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
bool bailout_on_minus_zero =
@ -4296,20 +4297,45 @@ void LCodeGen::DoMulConstIS(LMulConstIS* instr) {
}
break;
// All other cases cannot detect overflow, because it would probably be no
// faster than using the smull method in LMulI.
// TODO(jbramley): Investigate this, and add overflow support if it would
// be useful.
default:
ASSERT(!can_overflow);
// Multiplication by constant powers of two (and some related values)
// can be done efficiently with shifted operands.
if (right >= 0) {
if (IsPowerOf2(right)) {
int32_t right_abs = Abs(right);
if (IsPowerOf2(right_abs)) {
int right_log2 = WhichPowerOf2(right_abs);
if (can_overflow) {
Register scratch = result;
ASSERT(!AreAliased(scratch, left));
__ Cls(scratch, left);
__ Cmp(scratch, right_log2);
DeoptimizeIf(lt, instr->environment());
}
if (right >= 0) {
// result = left << log2(right)
__ Lsl(result, left, WhichPowerOf2(right));
} else if (IsPowerOf2(right - 1)) {
__ Lsl(result, left, right_log2);
} else {
// result = -left << log2(-right)
if (can_overflow) {
__ Negs(result, Operand(left, LSL, right_log2));
DeoptimizeIf(vs, instr->environment());
} else {
__ Neg(result, Operand(left, LSL, right_log2));
}
}
return;
}
// For the following cases, we could perform a conservative overflow check
// with CLS as above. However the few cycles saved are likely not worth
// the risk of deoptimizing more often than required.
ASSERT(!can_overflow);
if (right >= 0) {
if (IsPowerOf2(right - 1)) {
// result = left + left << log2(right - 1)
__ Add(result, left, Operand(left, LSL, WhichPowerOf2(right - 1)));
} else if (IsPowerOf2(right + 1)) {
@ -4320,10 +4346,7 @@ void LCodeGen::DoMulConstIS(LMulConstIS* instr) {
UNREACHABLE();
}
} else {
if (IsPowerOf2(-right)) {
// result = -left << log2(-right)
__ Neg(result, Operand(left, LSL, WhichPowerOf2(-right)));
} else if (IsPowerOf2(-right + 1)) {
if (IsPowerOf2(-right + 1)) {
// result = left - left << log2(-right + 1)
__ Sub(result, left, Operand(left, LSL, WhichPowerOf2(-right + 1)));
} else if (IsPowerOf2(-right - 1)) {
@ -4334,7 +4357,6 @@ void LCodeGen::DoMulConstIS(LMulConstIS* instr) {
UNREACHABLE();
}
}
break;
}
}