Emit VMLA for multiply-add on ARM

src/hydrogen.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 8264 matching lines @@
     HConstant* right_const = HConstant::cast(right);
     if (right_const->HasInteger32Value() &&
        (right_const->Integer32Value() & 0x1f) != 0) {
       return false;
     }
   }
   return true;
 }
 
 
+bool HGraphBuilder::MatchMultiplyAdd(HValue* left, HValue* right, HValue** a, HValue** b, HValue** c) {
+  if (right->IsMul()) {
+    HValue *tmp = left;
+    left = right;
+    right = tmp;
+  }
+  if (!left->IsMul())
+    return false;
+
+  HMul* mul = HMul::cast(left);
+  *a = mul->left();
+  *b = mul->right();
+  *c = right;
+  //printf("matched multiply-add\n");
+  return true;
+}
+
+
 HInstruction* HGraphBuilder::BuildBinaryOperation(BinaryOperation* expr,
                                                   HValue* left,
                                                   HValue* right) {
   HValue* context = environment()->LookupContext();
   TypeInfo info = oracle()->BinaryType(expr);
   if (info.IsUninitialized()) {
     AddInstruction(new(zone()) HSoftDeoptimize);
     current_block()->MarkAsDeoptimizing();
     info = TypeInfo::Unknown();
   }
   HInstruction* instr = NULL;
   switch (expr->op()) {
-    case Token::ADD:
+    case Token::ADD: {
+#ifdef V8_TARGET_ARCH_ARM
+      HValue* a, *b, *c;
+#endif
       if (info.IsString()) {
         AddInstruction(new(zone()) HCheckNonSmi(left));
         AddInstruction(HCheckInstanceType::NewIsString(left, zone()));
         AddInstruction(new(zone()) HCheckNonSmi(right));
         AddInstruction(HCheckInstanceType::NewIsString(right, zone()));
         instr = new(zone()) HStringAdd(context, left, right);
+#ifdef V8_TARGET_ARCH_ARM
+      } else if (info.IsDouble() && MatchMultiplyAdd(left, right, &a, &b, &c)) {
+        // FIXME: Probably need to check types here?

[ulan_google, 2012/11/07 09:54:03]

Setting input representation should be sufficient. Hydrogen will introduce
special change instructions for inputs.

+        // FIXME: I'm not sure I'm hooking this up correctly :/
+        instr = new(zone()) HMultiplyAdd(context, a, b, c);
+#endif
       } else {
         instr = HAdd::NewHAdd(zone(), context, left, right);
       }
       break;
+    }
     case Token::SUB:
       instr = HSub::NewHSub(zone(), context, left, right);
       break;
     case Token::MUL:
       instr = HMul::NewHMul(zone(), context, left, right);
       break;
     case Token::MOD:
       instr = HMod::NewHMod(zone(), context, left, right);
       break;
     case Token::DIV:
@@ skipping 1693 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal