Back out Stack D13119110..D13236159

Summary: backout, causes failures

Reviewed By: adityasharat

Differential Revision: D13376210

fbshipit-source-id: 1fa8823f2dce601c47738f34ddb2674288197e79

csharp/Facebook.Yoga/YogaConstants.cs

@@ -1,4 +1,4 @@
-/**
+/**
  * Copyright (c) Facebook, Inc. and its affiliates.
  *
  * This source code is licensed under the MIT license found in the
@@ -9,11 +9,28 @@ namespace Facebook.Yoga
 {
     public static class YogaConstants
     {
-        public const float Undefined = float.NaN;
+        /**
+         * Large positive number signifies that the property(float) is undefined. Earlier we used to have
+         * YGundefined as NAN, but the downside of this is that we can't use -ffast-math compiler flag as
+         * it assumes all floating-point calculation involve and result into finite numbers. For more
+         * information regarding -ffast-math compiler flag in clang, have a look at
+         * https://clang.llvm.org/docs/UsersManual.html#cmdoption-ffast-math
+         */
+        public const float Undefined = 10E20F;
 
         public static bool IsUndefined(float value)
         {
-            return float.IsNaN(value);
+            // Value of a float in the case of it being not defined is 10.1E20. Earlier it used to be NAN,
+            // the benefit of which
+            // was that if NAN is involved in any mathematical expression the result was NAN. But since we
+            // want to have `-ffast-math`
+            // flag being used by compiler which assumes that the floating point values are not NAN and Inf,
+            // we represent YGUndefined as 10.1E20.
+            // But now if YGUndefined is involved in any mathematical operations this value(10.1E20) would
+            // change.
+            // So the following check makes sure that if the value is outside a range (-10E8, 10E8) then it
+            // is undefined.
+            return value >= 10E8F || value <= -10E8;
         }
 
         public static bool IsUndefined(YogaValue value)

java/com/facebook/yoga/YogaConstants.java

@@ -1,17 +1,35 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
+/*
+ *  Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ *  This source code is licensed under the MIT license found in the LICENSE
+ *  file in the root directory of this source tree.
  *
- * This source code is licensed under the MIT license found in the LICENSE
- * file in the root directory of this source tree.
  */
 package com.facebook.yoga;
 
 public class YogaConstants {
 
-  public static final float UNDEFINED = Float.NaN;
+  /**
+   * Large positive number signifies that the property(float) is undefined. Earlier we used to have
+   * YGundefined as NAN, but the downside of this is that we can't use -ffast-math compiler flag as
+   * it assumes all floating-point calculation involve and result into finite numbers. For more
+   * information regarding -ffast-math compiler flag in clang, have a look at
+   * https://clang.llvm.org/docs/UsersManual.html#cmdoption-ffast-math
+   */
+  public static final float UNDEFINED = (float) (10E20);
 
   public static boolean isUndefined(float value) {
-    return Float.compare(value, UNDEFINED) == 0;
+    // Value of a float in the case of it being not defined is 10.1E20. Earlier it used to be NAN,
+    // the benefit of which
+    // was that if NAN is involved in any mathematical expression the result was NAN. But since we
+    // want to have `-ffast-math`
+    // flag being used by compiler which assumes that the floating point values are not NAN and Inf,
+    // we represent YGUndefined as 10.1E20.
+    // But now if YGUndefined is involved in any mathematical operations this value(10.1E20) would
+    // change.
+    // So the following check makes sure that if the value is outside a range (-10E8, 10E8) then it
+    // is undefined.
+    return (Float.compare(value, (float) 10E8) >= 0 || Float.compare(value, (float) -10E8) <= 0);
   }
 
   public static boolean isUndefined(YogaValue value) {

tools/build_defs/oss/yoga_defs.bzl

@@ -58,6 +58,7 @@ BASE_COMPILER_FLAGS = [
     "-Wall",
     "-Werror",
     "-O3",
+    "-ffast-math",
 ]
 
 LIBRARY_COMPILER_FLAGS = BASE_COMPILER_FLAGS + [

yoga/Utils.cpp

@@ -55,14 +55,15 @@ float YGFloatSanitize(const float val) {
   return yoga::isUndefined(val) ? 0 : val;
 }
 
+float YGUnwrapFloatOptional(const YGFloatOptional& op) {
+  return op.isUndefined() ? YGUndefined : op.getValue();
+}
+
 YGFloatOptional YGFloatOptionalMax(
-    const YGFloatOptional op1,
-    const YGFloatOptional op2) {
-  if (op1 > op2) {
-    return op1;
-  }
-  if (op2 > op1) {
-    return op2;
+    const YGFloatOptional& op1,
+    const YGFloatOptional& op2) {
+  if (!op1.isUndefined() && !op2.isUndefined()) {
+    return op1.getValue() > op2.getValue() ? op1 : op2;
   }
   return op1.isUndefined() ? op2 : op1;
 }

yoga/Utils.h

@@ -57,12 +57,22 @@ bool YGValueEqual(const YGValue a, const YGValue b);
 // difference between two floats is less than 0.0001f or both are undefined.
 bool YGFloatsEqual(const float a, const float b);
 
+// We need custom max function, since we want that, if one argument is
+// YGUndefined then the max funtion should return the other argument as the max
+// value. We wouldn't have needed a custom max function if YGUndefined was NAN
+// as fmax has the same behaviour, but with NAN we cannot use `-ffast-math`
+// compiler flag.
 float YGFloatMax(const float a, const float b);
 
 YGFloatOptional YGFloatOptionalMax(
-    const YGFloatOptional op1,
-    const YGFloatOptional op2);
-
+    const YGFloatOptional& op1,
+    const YGFloatOptional& op2);
+
+// We need custom min function, since we want that, if one argument is
+// YGUndefined then the min funtion should return the other argument as the min
+// value. We wouldn't have needed a custom min function if YGUndefined was NAN
+// as fmin has the same behaviour, but with NAN we cannot use `-ffast-math`
+// compiler flag.
 float YGFloatMin(const float a, const float b);
 
 // This custom float comparision function compares the array of float with
@@ -82,6 +92,11 @@ bool YGFloatArrayEqual(
 // This function returns 0 if YGFloatIsUndefined(val) is true and val otherwise
 float YGFloatSanitize(const float val);
 
+// This function unwraps optional and returns YGUndefined if not defined or
+// op.value otherwise
+// TODO: Get rid off this function
+float YGUnwrapFloatOptional(const YGFloatOptional& op);
+
 YGFlexDirection YGFlexDirectionCross(
     const YGFlexDirection flexDirection,
     const YGDirection direction);
@@ -91,17 +106,18 @@ inline bool YGFlexDirectionIsRow(const YGFlexDirection flexDirection) {
       flexDirection == YGFlexDirectionRowReverse;
 }
 
-inline YGFloatOptional YGResolveValue(
-    const YGValue value,
-    const float ownerSize) {
+inline YGFloatOptional YGResolveValue(const YGValue value, const float ownerSize) {
   switch (value.unit) {
+    case YGUnitUndefined:
+    case YGUnitAuto:
+      return YGFloatOptional();
     case YGUnitPoint:
-      return YGFloatOptional{value.value};
+      return YGFloatOptional(value.value);
     case YGUnitPercent:
-      return YGFloatOptional{value.value * ownerSize * 0.01f};
-    default:
-      return YGFloatOptional{};
+      return YGFloatOptional(
+          static_cast<float>(value.value * ownerSize * 0.01));
   }
+  return YGFloatOptional();
 }
 
 inline bool YGFlexDirectionIsColumn(const YGFlexDirection flexDirection) {
@@ -123,7 +139,7 @@ inline YGFlexDirection YGResolveFlexDirection(
   return flexDirection;
 }
 
-inline YGFloatOptional YGResolveValueMargin(
+static inline YGFloatOptional YGResolveValueMargin(
     const YGValue value,
     const float ownerSize) {
   return value.unit == YGUnitAuto ? YGFloatOptional(0)