Emit VMLA for multiply-add on ARM

src/arm/lithium-arm.cc

 // Copyright 2012 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
@@ skipping 1285 matching lines @@
       left = UseRegisterAtStart(instr->LeastConstantOperand());
     }
     LMulI* mul = new(zone()) LMulI(left, right, temp);
     if (instr->CheckFlag(HValue::kCanOverflow) ||
         instr->CheckFlag(HValue::kBailoutOnMinusZero)) {
       AssignEnvironment(mul);
     }
     return DefineAsRegister(mul);
 
   } else if (instr->representation().IsDouble()) {
+    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);
   }
 }
 
 
 LInstruction* LChunkBuilder::DoSub(HSub* instr) {
   if (instr->representation().IsInteger32()) {
     ASSERT(instr->left()->representation().IsInteger32());
     ASSERT(instr->right()->representation().IsInteger32());
@@ skipping 19 matching lines @@
     ASSERT(instr->right()->representation().IsInteger32());
     LOperand* left = UseRegisterAtStart(instr->LeastConstantOperand());
     LOperand* right = UseOrConstantAtStart(instr->MostConstantOperand());
     LAddI* add = new(zone()) LAddI(left, right);
     LInstruction* result = DefineAsRegister(add);
     if (instr->CheckFlag(HValue::kCanOverflow)) {
       result = AssignEnvironment(result);
     }
     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());
     return DoArithmeticT(Token::ADD, instr);
   }
 }
 
 
 LInstruction* LChunkBuilder::DoMathMinMax(HMathMinMax* instr) {
   LOperand* left = NULL;
@@ skipping 905 matching lines @@
 
 
 LInstruction* LChunkBuilder::DoLoadFieldByIndex(HLoadFieldByIndex* instr) {
   LOperand* object = UseRegister(instr->object());
   LOperand* index = UseRegister(instr->index());
   return DefineAsRegister(new(zone()) LLoadFieldByIndex(object, index));
 }
 
 
 } }  // namespace v8::internal