[turbofan] Introduce integer multiplication with overflow.

src/code-stubs.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/code-stubs.h"
 
 #include <sstream>
 
 #include "src/bootstrapper.h"
 #include "src/code-factory.h"
@@ skipping 1049 matching lines @@
 compiler::Node* MultiplyStub::Generate(CodeStubAssembler* assembler,
                                        compiler::Node* left,
                                        compiler::Node* right,
                                        compiler::Node* context) {
   using compiler::Node;
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
 
   // Shared entry point for floating point multiplication.
   Label do_fmul(assembler);
+  Label end(assembler);

[Benedikt Meurer, 2016/07/12 04:09:28]

Nit: Can you rename this to return_result and add it to the preceeding line,
i.e.:

Label do_fmul(assembler), return_result(assembler);

[mvstanton, 2016/07/12 08:52:49]

Done.

   Variable var_lhs_float64(assembler, MachineRepresentation::kFloat64),
       var_rhs_float64(assembler, MachineRepresentation::kFloat64);
 
   Node* number_map = assembler->HeapNumberMapConstant();
 
   // We might need to loop one or two times due to ToNumber conversions.
   Variable var_lhs(assembler, MachineRepresentation::kTagged),
-      var_rhs(assembler, MachineRepresentation::kTagged);
+      var_rhs(assembler, MachineRepresentation::kTagged),
+      var_result(assembler, MachineRepresentation::kTagged);
   Variable* loop_variables[] = {&var_lhs, &var_rhs};
   Label loop(assembler, 2, loop_variables);
   var_lhs.Bind(left);
   var_rhs.Bind(right);
   assembler->Goto(&loop);
   assembler->Bind(&loop);
   {
     Node* lhs = var_lhs.value();
     Node* rhs = var_rhs.value();
 
     Label lhs_is_smi(assembler), lhs_is_not_smi(assembler);
     assembler->Branch(assembler->WordIsSmi(lhs), &lhs_is_smi, &lhs_is_not_smi);
 
     assembler->Bind(&lhs_is_smi);
     {
       Label rhs_is_smi(assembler), rhs_is_not_smi(assembler);
       assembler->Branch(assembler->WordIsSmi(rhs), &rhs_is_smi,
                         &rhs_is_not_smi);
 
       assembler->Bind(&rhs_is_smi);
       {
         // Both {lhs} and {rhs} are Smis. Convert them to double and multiply.
         // TODO(epertoso): use SmiMulWithOverflow once available.

[Benedikt Meurer, 2016/07/12 04:09:28]

Remove this TODO.

[mvstanton, 2016/07/12 08:52:49]

Done.

+        Node* lhs32 = assembler->SmiToWord32(lhs);
+        Node* rhs32 = assembler->SmiToWord32(rhs);
+        Node* pair = assembler->Int32MulWithOverflow(lhs32, rhs32);
+
+        Node* overflow = assembler->Projection(1, pair);
+
+        // Check if the multiplication overflowed.
+        Label if_overflow(assembler), if_notoverflow(assembler);

[Benedikt Meurer, 2016/07/12 04:09:28]

Make the if_overflow label deferred.

[mvstanton, 2016/07/12 08:52:49]

Done.

+        assembler->Branch(overflow, &if_overflow, &if_notoverflow);
+
+        assembler->Bind(&if_notoverflow);

[Benedikt Meurer, 2016/07/12 04:09:28]

Add braces around the actual blocks for improved readability.

[mvstanton, 2016/07/12 08:52:49]

Done.

+        // If the answer is zero, we may need to return -0.0, depending on the
+        // input.
+        Label answer_zero(assembler), answer_not_zero(assembler);
+        Node* answer = assembler->Projection(0, pair);
+        Node* zero = assembler->Int32Constant(0);
+        assembler->Branch(assembler->WordEqual(answer, zero), &answer_zero,
+                          &answer_not_zero);
+
+        assembler->Bind(&answer_not_zero);
+        var_result.Bind(assembler->ChangeInt32ToTagged(answer));
+        assembler->Goto(&end);
+
+        assembler->Bind(&answer_zero);
+        Node* or_result = assembler->Word32Or(lhs32, rhs32);
+        Label if_should_be_negative_zero(assembler),
+            if_should_be_zero(assembler);
+        assembler->Branch(assembler->Int32LessThan(or_result, zero),
+                          &if_should_be_negative_zero, &if_should_be_zero);
+        assembler->Bind(&if_should_be_negative_zero);
+        var_result.Bind(assembler->MinusZeroConstant());
+        assembler->Goto(&end);
+
+        assembler->Bind(&if_should_be_zero);
+        var_result.Bind(zero);
+        assembler->Goto(&end);
+
+        assembler->Bind(&if_overflow);
         var_lhs_float64.Bind(assembler->SmiToFloat64(lhs));
         var_rhs_float64.Bind(assembler->SmiToFloat64(rhs));
         assembler->Goto(&do_fmul);
       }
 
       assembler->Bind(&rhs_is_not_smi);
       {
         Node* rhs_map = assembler->LoadMap(rhs);
 
         // Check if {rhs} is a HeapNumber.
@@ skipping 83 matching lines @@
         assembler->Goto(&loop);
       }
     }
   }
 
   assembler->Bind(&do_fmul);
   {
     Node* value =
         assembler->Float64Mul(var_lhs_float64.value(), var_rhs_float64.value());
     Node* result = assembler->ChangeFloat64ToTagged(value);
-    return result;
+    var_result.Bind(result);
+    assembler->Goto(&end);
   }
+
+  assembler->Bind(&end);
+  return var_result.value();
 }
 
 // static
 compiler::Node* DivideStub::Generate(CodeStubAssembler* assembler,
                                      compiler::Node* left,
                                      compiler::Node* right,
                                      compiler::Node* context) {
   using compiler::Node;
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
@@ skipping 3714 matching lines @@
   if (type->Is(Type::UntaggedPointer())) {
     return Representation::External();
   }
 
   DCHECK(!type->Is(Type::Untagged()));
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8