Emit VMLA for multiply-add on ARM

src/arm/lithium-arm.cc

Index: src/arm/lithium-arm.cc
diff --git a/src/arm/lithium-arm.cc b/src/arm/lithium-arm.cc
index 17f3325b754c3449f682425313062cf438c8d581..70ced1cf9e6af0072f3ae35783fe6ef30464e293 100644
--- a/src/arm/lithium-arm.cc
+++ b/src/arm/lithium-arm.cc
@@ -1303,8 +1303,21 @@ LInstruction* LChunkBuilder::DoMul(HMul* instr) {
     return DefineAsRegister(mul);
 
   } else if (instr->representation().IsDouble()) {
-    return DoArithmeticD(Token::MUL, instr);
+    if (instr->UseCount() == 1 && instr->uses().value()->IsAdd()) {
+      HAdd* add = HAdd::cast(instr->uses().value());
+      if (instr == add->left()) {
+        // This mul is the lhs of an add. The add and mul will be folded
+        // into a multiply-add.
+        return NULL;
+      }
+      if (instr == add->right() && !add->left()->IsMul()) {
+        // This mul is the rhs of an add, where the lhs is not another mul.
+        // The add and mul will be folded into a multiply-add.
+        return NULL;
+      }
+    }
 
+    return DoArithmeticD(Token::MUL, instr);
   } else {
     return DoArithmeticT(Token::MUL, instr);
   }
@@ -1344,6 +1357,25 @@ LInstruction* LChunkBuilder::DoAdd(HAdd* instr) {
     }
     return result;
   } else if (instr->representation().IsDouble()) {
+    // Fold a * b + c into LMultiplyAddD.
+    if (instr->left()->IsMul()) {

[Sven Panne, 2012/11/13 13:03:52]

Style issue: Please use a helper function here and below, it makes things
clearer, removing the need for the comment above.

LInstruction* LChunkBuilder::DoMultiplyAdd(HMul* mul, HInstruction* summand) {
  LOperand* a = UseRegisterAtStart(mul->left());
  LOperand* b = UseRegisterAtStart(mul->right());
  LOperand* c = UseRegister(summand);
  return DefineSameAsFirst(new(zone()) LMultiplyAddD(c, a, b));
}

[hans, 2012/11/13 14:59:58]

Done.

I noticed that you changed from UseRegisterAtStart to UseRegister for c. Was
that intentional? I'm still confused about what to use here. The instruction
does use the value of c, so it doesn't just need a register that it can clobber.

+      HMul* mul = HMul::cast(instr->left());
+      LOperand* a = UseRegisterAtStart(mul->left());
+      LOperand* b = UseRegisterAtStart(mul->right());
+      LOperand* c = UseRegisterAtStart(instr->right());
+      LMultiplyAddD* result = new(zone()) LMultiplyAddD(c, a, b);
+      return DefineSameAsFirst(result);
+    }
+    // Fold c + a * b into LMultiplyAdd.
+    if (instr->right()->IsMul()) {

[Jakob Kummerow, 2012/11/13 13:05:21]

Please add an ASSERT(!instr->left()->IsMul()) inside this block. That situation
is currently guaranteed, but for the benefit of future refactorings I'd like to
document that it is a necessity.

[hans, 2012/11/13 14:59:58]

Done.

+      HMul* mul = HMul::cast(instr->right());
+      LOperand* c = UseRegisterAtStart(instr->left());
+      LOperand* a = UseRegisterAtStart(mul->left());
+      LOperand* b = UseRegisterAtStart(mul->right());
+      LMultiplyAddD* result = new(zone()) LMultiplyAddD(c, a, b);
+      return DefineSameAsFirst(result);
+    }
+
     return DoArithmeticD(Token::ADD, instr);
   } else {
     ASSERT(instr->representation().IsTagged());