[turbofan] introduce Int32/64AbsWithOverflow optional operator

src/builtins/builtins-math-gen.cc

 // Copyright 2017 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/builtins/builtins-utils-gen.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 
 namespace v8 {
@@ skipping 30 matching lines @@
   {
     // Load the current {x} value.
     Node* x = var_x.value();
 
     // Check if {x} is a Smi or a HeapObject.
     Label if_xissmi(this), if_xisnotsmi(this);
     Branch(TaggedIsSmi(x), &if_xissmi, &if_xisnotsmi);
 
     Bind(&if_xissmi);
     {
-      // Check if {x} is already positive.
-      Label if_xispositive(this), if_xisnotpositive(this);
-      BranchIfSmiLessThanOrEqual(SmiConstant(Smi::FromInt(0)), x,
-                                 &if_xispositive, &if_xisnotpositive);
+      Label if_overflow(this, Label::kDeferred), if_notoverflow(this);
+      Node* pair = NULL;
 
-      Bind(&if_xispositive);
-      {
-        // Just return the input {x}.
-        Return(x);
+      // check if support abs function
+      if (IsIntPtrAbsWithOverflowSupported()) {
+        pair = IntPtrAbsWithOverflow(x);
+        Node* overflow = Projection(1, pair);
+        Branch(overflow, &if_overflow, &if_notoverflow);
+      } else {
+        // Check if {x} is already positive.
+        Label if_xispositive(this), if_xisnotpositive(this);
+        BranchIfSmiLessThanOrEqual(SmiConstant(Smi::FromInt(0)), x,
+                                   &if_xispositive, &if_xisnotpositive);
+
+        Bind(&if_xispositive);
+        {
+          // Just return the input {x}.
+          Return(x);
+        }
+
+        Bind(&if_xisnotpositive);
+        {
+          // Try to negate the {x} value.
+          pair =
+              IntPtrSubWithOverflow(IntPtrConstant(0), BitcastTaggedToWord(x));
+          Node* overflow = Projection(1, pair);
+          Branch(overflow, &if_overflow, &if_notoverflow);
+        }
       }
 
-      Bind(&if_xisnotpositive);
+      Bind(&if_notoverflow);
       {
-        // Try to negate the {x} value.
-        Node* pair =
-            IntPtrSubWithOverflow(IntPtrConstant(0), BitcastTaggedToWord(x));
-        Node* overflow = Projection(1, pair);
-        Label if_overflow(this, Label::kDeferred), if_notoverflow(this);
-        Branch(overflow, &if_overflow, &if_notoverflow);
+        // There is a Smi representation for negated {x}.
+        Node* result = Projection(0, pair);
+        Return(BitcastWordToTagged(result));
+      }
 
-        Bind(&if_notoverflow);
-        {
-          // There is a Smi representation for negated {x}.
-          Node* result = Projection(0, pair);
-          Return(BitcastWordToTagged(result));
-        }
-
-        Bind(&if_overflow);
-        { Return(NumberConstant(0.0 - Smi::kMinValue)); }
-      }
+      Bind(&if_overflow);
+      { Return(NumberConstant(0.0 - Smi::kMinValue)); }
     }
 
     Bind(&if_xisnotsmi);
     {
       // Check if {x} is a HeapNumber.
       Label if_xisheapnumber(this), if_xisnotheapnumber(this, Label::kDeferred);
       Branch(IsHeapNumberMap(LoadMap(x)), &if_xisheapnumber,
              &if_xisnotheapnumber);
 
       Bind(&if_xisheapnumber);
@@ skipping 429 matching lines @@
 TF_BUILTIN(MathMin, MathBuiltinsAssembler) {
   // TODO(ishell): use constants from Descriptor once the JSFunction linkage
   // arguments are reordered.
   Node* context = Parameter(BuiltinDescriptor::kContext);
   Node* argc = Parameter(BuiltinDescriptor::kArgumentsCount);
   MathMaxMin(context, argc, &CodeStubAssembler::Float64Min, V8_INFINITY);
 }
 
 }  // namespace internal
 }  // namespace v8