Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 2 of 2.

1 files changed, 138 insertions, 138 deletions

diff --git a/contrib/libs/cxxsupp/builtins/comparetf2.c b/contrib/libs/cxxsupp/builtins/comparetf2.c
index 0b4c16b1e3..c0ad8ed0ae 100644
--- a/contrib/libs/cxxsupp/builtins/comparetf2.c
+++ b/contrib/libs/cxxsupp/builtins/comparetf2.c
@@ -1,138 +1,138 @@
-//===-- lib/comparetf2.c - Quad-precision comparisons -------------*- C -*-===// 
-// 
-//                     The LLVM Compiler Infrastructure 
-// 
-// This file is dual licensed under the MIT and the University of Illinois Open 
-// Source Licenses. See LICENSE.TXT for details. 
-// 
-//===----------------------------------------------------------------------===// 
-// 
-// // This file implements the following soft-float comparison routines: 
-// 
-//   __eqtf2   __getf2   __unordtf2 
-//   __letf2   __gttf2 
-//   __lttf2 
-//   __netf2 
-// 
-// The semantics of the routines grouped in each column are identical, so there 
-// is a single implementation for each, and wrappers to provide the other names. 
-// 
-// The main routines behave as follows: 
-// 
-//   __letf2(a,b) returns -1 if a < b 
-//                         0 if a == b 
-//                         1 if a > b 
-//                         1 if either a or b is NaN 
-// 
-//   __getf2(a,b) returns -1 if a < b 
-//                         0 if a == b 
-//                         1 if a > b 
-//                        -1 if either a or b is NaN 
-// 
-//   __unordtf2(a,b) returns 0 if both a and b are numbers 
-//                           1 if either a or b is NaN 
-// 
-// Note that __letf2( ) and __getf2( ) are identical except in their handling of 
-// NaN values. 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#define QUAD_PRECISION 
-#include "fp_lib.h" 
- 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) 
-enum LE_RESULT { 
-    LE_LESS      = -1, 
-    LE_EQUAL     =  0, 
-    LE_GREATER   =  1, 
-    LE_UNORDERED =  1 
-}; 
- 
-COMPILER_RT_ABI enum LE_RESULT __letf2(fp_t a, fp_t b) { 
- 
-    const srep_t aInt = toRep(a); 
-    const srep_t bInt = toRep(b); 
-    const rep_t aAbs = aInt & absMask; 
-    const rep_t bAbs = bInt & absMask; 
- 
-    // If either a or b is NaN, they are unordered. 
-    if (aAbs > infRep || bAbs > infRep) return LE_UNORDERED; 
- 
-    // If a and b are both zeros, they are equal. 
-    if ((aAbs | bAbs) == 0) return LE_EQUAL; 
- 
-    // If at least one of a and b is positive, we get the same result comparing 
-    // a and b as signed integers as we would with a floating-point compare. 
-    if ((aInt & bInt) >= 0) { 
-        if (aInt < bInt) return LE_LESS; 
-        else if (aInt == bInt) return LE_EQUAL; 
-        else return LE_GREATER; 
-    } 
-    else { 
-        // Otherwise, both are negative, so we need to flip the sense of the 
-        // comparison to get the correct result.  (This assumes a twos- or ones- 
-        // complement integer representation; if integers are represented in a 
-        // sign-magnitude representation, then this flip is incorrect). 
-        if (aInt > bInt) return LE_LESS; 
-        else if (aInt == bInt) return LE_EQUAL; 
-        else return LE_GREATER; 
-    } 
-} 
- 
-#if defined(__ELF__) 
-// Alias for libgcc compatibility 
-FNALIAS(__cmptf2, __letf2); 
-#endif 
- 
-enum GE_RESULT { 
-    GE_LESS      = -1, 
-    GE_EQUAL     =  0, 
-    GE_GREATER   =  1, 
-    GE_UNORDERED = -1   // Note: different from LE_UNORDERED 
-}; 
- 
-COMPILER_RT_ABI enum GE_RESULT __getf2(fp_t a, fp_t b) { 
- 
-    const srep_t aInt = toRep(a); 
-    const srep_t bInt = toRep(b); 
-    const rep_t aAbs = aInt & absMask; 
-    const rep_t bAbs = bInt & absMask; 
- 
-    if (aAbs > infRep || bAbs > infRep) return GE_UNORDERED; 
-    if ((aAbs | bAbs) == 0) return GE_EQUAL; 
-    if ((aInt & bInt) >= 0) { 
-        if (aInt < bInt) return GE_LESS; 
-        else if (aInt == bInt) return GE_EQUAL; 
-        else return GE_GREATER; 
-    } else { 
-        if (aInt > bInt) return GE_LESS; 
-        else if (aInt == bInt) return GE_EQUAL; 
-        else return GE_GREATER; 
-    } 
-} 
- 
-COMPILER_RT_ABI int __unordtf2(fp_t a, fp_t b) { 
-    const rep_t aAbs = toRep(a) & absMask; 
-    const rep_t bAbs = toRep(b) & absMask; 
-    return aAbs > infRep || bAbs > infRep; 
-} 
- 
-// The following are alternative names for the preceding routines. 
- 
-COMPILER_RT_ABI enum LE_RESULT __eqtf2(fp_t a, fp_t b) { 
-    return __letf2(a, b); 
-} 
- 
-COMPILER_RT_ABI enum LE_RESULT __lttf2(fp_t a, fp_t b) { 
-    return __letf2(a, b); 
-} 
- 
-COMPILER_RT_ABI enum LE_RESULT __netf2(fp_t a, fp_t b) { 
-    return __letf2(a, b); 
-} 
- 
-COMPILER_RT_ABI enum GE_RESULT __gttf2(fp_t a, fp_t b) { 
-    return __getf2(a, b); 
-} 
- 
-#endif 
+//===-- lib/comparetf2.c - Quad-precision comparisons -------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// // This file implements the following soft-float comparison routines:
+//
+//   __eqtf2   __getf2   __unordtf2
+//   __letf2   __gttf2
+//   __lttf2
+//   __netf2
+//
+// The semantics of the routines grouped in each column are identical, so there
+// is a single implementation for each, and wrappers to provide the other names.
+//
+// The main routines behave as follows:
+//
+//   __letf2(a,b) returns -1 if a < b
+//                         0 if a == b
+//                         1 if a > b
+//                         1 if either a or b is NaN
+//
+//   __getf2(a,b) returns -1 if a < b
+//                         0 if a == b
+//                         1 if a > b
+//                        -1 if either a or b is NaN
+//
+//   __unordtf2(a,b) returns 0 if both a and b are numbers
+//                           1 if either a or b is NaN
+//
+// Note that __letf2( ) and __getf2( ) are identical except in their handling of
+// NaN values.
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+enum LE_RESULT {
+    LE_LESS      = -1,
+    LE_EQUAL     =  0,
+    LE_GREATER   =  1,
+    LE_UNORDERED =  1
+};
+
+COMPILER_RT_ABI enum LE_RESULT __letf2(fp_t a, fp_t b) {
+
+    const srep_t aInt = toRep(a);
+    const srep_t bInt = toRep(b);
+    const rep_t aAbs = aInt & absMask;
+    const rep_t bAbs = bInt & absMask;
+
+    // If either a or b is NaN, they are unordered.
+    if (aAbs > infRep || bAbs > infRep) return LE_UNORDERED;
+
+    // If a and b are both zeros, they are equal.
+    if ((aAbs | bAbs) == 0) return LE_EQUAL;
+
+    // If at least one of a and b is positive, we get the same result comparing
+    // a and b as signed integers as we would with a floating-point compare.
+    if ((aInt & bInt) >= 0) {
+        if (aInt < bInt) return LE_LESS;
+        else if (aInt == bInt) return LE_EQUAL;
+        else return LE_GREATER;
+    }
+    else {
+        // Otherwise, both are negative, so we need to flip the sense of the
+        // comparison to get the correct result.  (This assumes a twos- or ones-
+        // complement integer representation; if integers are represented in a
+        // sign-magnitude representation, then this flip is incorrect).
+        if (aInt > bInt) return LE_LESS;
+        else if (aInt == bInt) return LE_EQUAL;
+        else return LE_GREATER;
+    }
+}
+
+#if defined(__ELF__)
+// Alias for libgcc compatibility
+FNALIAS(__cmptf2, __letf2);
+#endif
+
+enum GE_RESULT {
+    GE_LESS      = -1,
+    GE_EQUAL     =  0,
+    GE_GREATER   =  1,
+    GE_UNORDERED = -1   // Note: different from LE_UNORDERED
+};
+
+COMPILER_RT_ABI enum GE_RESULT __getf2(fp_t a, fp_t b) {
+
+    const srep_t aInt = toRep(a);
+    const srep_t bInt = toRep(b);
+    const rep_t aAbs = aInt & absMask;
+    const rep_t bAbs = bInt & absMask;
+
+    if (aAbs > infRep || bAbs > infRep) return GE_UNORDERED;
+    if ((aAbs | bAbs) == 0) return GE_EQUAL;
+    if ((aInt & bInt) >= 0) {
+        if (aInt < bInt) return GE_LESS;
+        else if (aInt == bInt) return GE_EQUAL;
+        else return GE_GREATER;
+    } else {
+        if (aInt > bInt) return GE_LESS;
+        else if (aInt == bInt) return GE_EQUAL;
+        else return GE_GREATER;
+    }
+}
+
+COMPILER_RT_ABI int __unordtf2(fp_t a, fp_t b) {
+    const rep_t aAbs = toRep(a) & absMask;
+    const rep_t bAbs = toRep(b) & absMask;
+    return aAbs > infRep || bAbs > infRep;
+}
+
+// The following are alternative names for the preceding routines.
+
+COMPILER_RT_ABI enum LE_RESULT __eqtf2(fp_t a, fp_t b) {
+    return __letf2(a, b);
+}
+
+COMPILER_RT_ABI enum LE_RESULT __lttf2(fp_t a, fp_t b) {
+    return __letf2(a, b);
+}
+
+COMPILER_RT_ABI enum LE_RESULT __netf2(fp_t a, fp_t b) {
+    return __letf2(a, b);
+}
+
+COMPILER_RT_ABI enum GE_RESULT __gttf2(fp_t a, fp_t b) {
+    return __getf2(a, b);
+}
+
+#endif