[builtins] Avoid enum name conflicts with fenv.h

[arichardson]

Summary

After a follow-up change (D98332) this header can be included the same time
as fenv.h when running the tests. To avoid enum members conflicting with
the macros/enums defined in the host fenv.h, prefix them with CRT_.

[arichardson]

• fix one FE_ROUND_MODE I missed in the previous version

[arichardson]

clang-format

[arichardson]

ping?

[peter.smith]

LGTM. Seems sensible to avoid a name clash with a standard header.

compiler-rt/lib/builtins/aarch64/fp_mode.c

#define AARCH64_RMODE_MASK (AARCH64_TONEAREST | AARCH64_UPWARD | \
                             AARCH64_DOWNWARD | AARCH64_TOWARDZERO)
 #define AARCH64_RMODE_SHIFT 22
 
 #define AARCH64_INEXACT     0x10
 
 #ifndef __ARM_FP
 // For soft float targets, allow changing rounding mode by overriding the weak
 // __aarch64_fe_default_rmode symbol.
-FE_ROUND_MODE __attribute__((weak)) __aarch64_fe_default_rmode = FE_TONEAREST;
+FE_ROUND_MODE __attribute__((weak)) __aarch64_fe_default_rmode = CRT_FE_TONEAREST;
 #endif
 
-FE_ROUND_MODE __fe_getround() {
+CRT_FE_ROUND_MODE __fe_getround() {
 #ifdef __ARM_FP
   uint64_t fpcr;
   __asm__ __volatile__("mrs  %0, fpcr" : "=r" (fpcr));
   fpcr = fpcr >> AARCH64_RMODE_SHIFT & AARCH64_RMODE_MASK;
   switch (fpcr) {
     case AARCH64_UPWARD:
-      return FE_UPWARD;
+      return CRT_FE_UPWARD;
     case AARCH64_DOWNWARD:
-      return FE_DOWNWARD;
+      return CRT_FE_DOWNWARD;
     case AARCH64_TOWARDZERO:
-      return FE_TOWARDZERO;
+      return CRT_FE_TOWARDZERO;
     case AARCH64_TONEAREST:
     default:
-      return FE_TONEAREST;
+      return CRT_FE_TONEAREST;
   }
 #else
   return __aarch64_fe_default_rmode;
 #endif
 }
 
 int __fe_raise_inexact() {
 #ifdef __ARM_FP
   uint64_t fpsr;
   __asm__ __volatile__("mrs  %0, fpsr" : "=r" (fpsr));
   __asm__ __volatile__("msr  fpsr, %0" : : "ri" (fpsr | AARCH64_INEXACT));
   return 0;
 #else
   return 0;
 #endif
 }

compiler-rt/lib/builtins/arm/fp_mode.c

#define ARM_RMODE_MASK (ARM_TONEAREST | ARM_UPWARD | \
                         ARM_DOWNWARD | ARM_TOWARDZERO)
 #define ARM_RMODE_SHIFT 22
 
 #define ARM_INEXACT     0x1000
 
 #ifndef __ARM_FP
 // For soft float targets, allow changing rounding mode by overriding the weak
 // __arm_fe_default_rmode symbol.
-FE_ROUND_MODE __attribute__((weak)) __arm_fe_default_rmode = FE_TONEAREST;
+CRT_FE_ROUND_MODE __attribute__((weak)) __arm_fe_default_rmode = CRT_FE_TONEAREST;
 #endif
 
-FE_ROUND_MODE __fe_getround() {
+CRT_FE_ROUND_MODE __fe_getround() {
 #ifdef __ARM_FP
   uint32_t fpscr;
   __asm__ __volatile__("vmrs  %0, fpscr" : "=r" (fpscr));
   fpscr = fpscr >> ARM_RMODE_SHIFT & ARM_RMODE_MASK;
   switch (fpscr) {
     case ARM_UPWARD:
-      return FE_UPWARD;
+      return CRT_FE_UPWARD;
     case ARM_DOWNWARD:
-      return FE_DOWNWARD;
+      return CRT_FE_DOWNWARD;
     case ARM_TOWARDZERO:
-      return FE_TOWARDZERO;
+      return CRT_FE_TOWARDZERO;
     case ARM_TONEAREST:
     default:
-      return FE_TONEAREST;
+      return CRT_FE_TONEAREST;
   }
 #else
   return __arm_fe_default_rmode;
 #endif
 }
 
 int __fe_raise_inexact() {
 #ifdef __ARM_FP
   uint32_t fpscr;
   __asm__ __volatile__("vmrs  %0, fpscr" : "=r" (fpscr));
   __asm__ __volatile__("vmsr  fpscr, %0" : : "ri" (fpscr | ARM_INEXACT));
   return 0;
 #else
   return 0;
 #endif
 }

compiler-rt/lib/builtins/fp_add_impl.inc

 //===----- lib/fp_add_impl.inc - floaing point addition -----------*- C -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements soft-float addition with the IEEE-754 default rounding
 // (to nearest, ties to even).
 //
 //===----------------------------------------------------------------------===//
 
 #include "fp_lib.h"
 #include "fp_mode.h"
 
 static __inline fp_t __addXf3__(fp_t a, fp_t b) {
   rep_t aRep = toRep(a);
   rep_t bRep = toRep(b);
   const rep_t aAbs = aRep & absMask;
   const rep_t bAbs = bRep & absMask;
 
   // Detect if a or b is zero, infinity, or NaN.
   if (aAbs - REP_C(1) >= infRep - REP_C(1) ||
       bAbs - REP_C(1) >= infRep - REP_C(1)) {
     // NaN + anything = qNaN
     if (aAbs > infRep)
       return fromRep(toRep(a) | quietBit);
     // anything + NaN = qNaN
     if (bAbs > infRep)
       return fromRep(toRep(b) | quietBit);
 
     if (aAbs == infRep) {
       // +/-infinity + -/+infinity = qNaN
       if ((toRep(a) ^ toRep(b)) == signBit)
         return fromRep(qnanRep);
       // +/-infinity + anything remaining = +/- infinity
       else
         return a;
     }
 
static __inline fp_t __addXf3__(fp_t a, fp_t b) {
 
   // Insert the exponent and sign.
   result |= (rep_t)aExponent << significandBits;
   result |= resultSign;
 
   // Perform the final rounding.  The result may overflow to infinity, but
   // that is the correct result in that case.
   switch (__fe_getround()) {
-  case FE_TONEAREST:
+  case CRT_FE_TONEAREST:
     if (roundGuardSticky > 0x4)
       result++;
     if (roundGuardSticky == 0x4)
       result += result & 1;
     break;
-  case FE_DOWNWARD:
+  case CRT_FE_DOWNWARD:
     if (resultSign && roundGuardSticky) result++;
     break;
-  case FE_UPWARD:
+  case CRT_FE_UPWARD:
     if (!resultSign && roundGuardSticky) result++;
     break;
-  case FE_TOWARDZERO:
+  case CRT_FE_TOWARDZERO:
     break;
   }
   if (roundGuardSticky)
     __fe_raise_inexact();
   return fromRep(result);
 }

compiler-rt/lib/builtins/fp_mode.h

 // environment mode.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FP_MODE
 #define FP_MODE
 
 typedef enum {
-  FE_TONEAREST,
-  FE_DOWNWARD,
-  FE_UPWARD,
-  FE_TOWARDZERO
-} FE_ROUND_MODE;
+  CRT_FE_TONEAREST,
+  CRT_FE_DOWNWARD,
+  CRT_FE_UPWARD,
+  CRT_FE_TOWARDZERO
+} CRT_FE_ROUND_MODE;
 
-FE_ROUND_MODE __fe_getround(void);
+CRT_FE_ROUND_MODE __fe_getround(void);
 int __fe_raise_inexact(void);
 
 #endif // FP_MODE_H

compiler-rt/lib/builtins/fp_mode.c

 // that does not support or does not have an implementation of floating point
 // environment mode.
 //
 //===----------------------------------------------------------------------===//
 
 #include "fp_mode.h"
 
 // IEEE-754 default rounding (to nearest, ties to even).
-FE_ROUND_MODE __fe_getround() {
-  return FE_TONEAREST;
+CRT_FE_ROUND_MODE __fe_getround() {
+  return CRT_FE_TONEAREST;
 }
 
 int __fe_raise_inexact() {
   return 0;
 }

compiler-rt/lib/builtins/i386/fp_mode.c

 //===----- lib/i386/fp_mode.c - Floaing-point mode utilities -----*- C -*-====//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "../fp_mode.h"
 
 #define X87_TONEAREST  0x0000
 #define X87_DOWNWARD   0x0400
 #define X87_UPWARD     0x0800
 #define X87_TOWARDZERO 0x0c00
 #define X87_RMODE_MASK (X87_TONEAREST | X87_UPWARD | X87_DOWNWARD | X87_TOWARDZERO)
 
-FE_ROUND_MODE __fe_getround() {
+CRT_FE_ROUND_MODE __fe_getround() {
   // Assume that the rounding mode state for the fpu agrees with the SSE unit.
   unsigned short cw;
   __asm__ __volatile__ ("fnstcw %0" : "=m" (cw));
 
   switch (cw & X87_RMODE_MASK) {
     case X87_TONEAREST:
-      return FE_TONEAREST;
+      return CRT_FE_TONEAREST;
     case X87_DOWNWARD:
-      return FE_DOWNWARD;
+      return CRT_FE_DOWNWARD;
     case X87_UPWARD:
-      return FE_UPWARD;
+      return CRT_FE_UPWARD;
     case X87_TOWARDZERO:
-      return FE_TOWARDZERO;
+      return CRT_FE_TOWARDZERO;
   }
-  return FE_TONEAREST;
+  return CRT_FE_TONEAREST;
 }
 
 int __fe_raise_inexact() {
   float f = 1.0f, g = 3.0f;
   __asm__ __volatile__ ("fdivs %1" : "+t" (f) : "m" (g));
   return 0;
 }