Rename fpe.* to fp.*

Author: spavloff

clang/test/CodeGen/strictfp_builtins.c

@@ -31,21 +31,21 @@ void p(char *str, int x) {
 // CHECK-NEXT:    [[D_ADDR:%.*]] = alloca double, align 8
 // CHECK-NEXT:    store double [[D:%.*]], ptr [[D_ADDR]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load double, ptr [[D_ADDR]], align 8
-// CHECK-NEXT:    [[ISZERO:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f64(double [[TMP0]], double 0.000000e+00, metadata !"oeq", metadata !"fpexcept.strict") #[[ATTR5:[0-9]+]] [ "fpe.except"(metadata !"strict") ]
+// CHECK-NEXT:    [[ISZERO:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f64(double [[TMP0]], double 0.000000e+00, metadata !"oeq", metadata !"fpexcept.strict") #[[ATTR5:[0-9]+]] [ "fp.except"(metadata !"strict") ]
 // CHECK-NEXT:    br i1 [[ISZERO]], label [[FPCLASSIFY_END:%.*]], label [[FPCLASSIFY_NOT_ZERO:%.*]]
 // CHECK:       fpclassify_end:
 // CHECK-NEXT:    [[FPCLASSIFY_RESULT:%.*]] = phi i32 [ 4, [[ENTRY:%.*]] ], [ 0, [[FPCLASSIFY_NOT_ZERO]] ], [ 1, [[FPCLASSIFY_NOT_NAN:%.*]] ], [ [[TMP2:%.*]], [[FPCLASSIFY_NOT_INF:%.*]] ]
 // CHECK-NEXT:    call void @p(ptr noundef @.str.1, i32 noundef [[FPCLASSIFY_RESULT]]) #[[ATTR4]]
 // CHECK-NEXT:    ret void
 // CHECK:       fpclassify_not_zero:
-// CHECK-NEXT:    [[CMP:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f64(double [[TMP0]], double [[TMP0]], metadata !"uno", metadata !"fpexcept.strict") #[[ATTR5]] [ "fpe.except"(metadata !"strict") ]
+// CHECK-NEXT:    [[CMP:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f64(double [[TMP0]], double [[TMP0]], metadata !"uno", metadata !"fpexcept.strict") #[[ATTR5]] [ "fp.except"(metadata !"strict") ]
 // CHECK-NEXT:    br i1 [[CMP]], label [[FPCLASSIFY_END]], label [[FPCLASSIFY_NOT_NAN]]
 // CHECK:       fpclassify_not_nan:
 // CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.fabs.f64(double [[TMP0]]) #[[ATTR6:[0-9]+]]
-// CHECK-NEXT:    [[ISINF:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f64(double [[TMP1]], double 0x7FF0000000000000, metadata !"oeq", metadata !"fpexcept.strict") #[[ATTR5]] [ "fpe.except"(metadata !"strict") ]
+// CHECK-NEXT:    [[ISINF:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f64(double [[TMP1]], double 0x7FF0000000000000, metadata !"oeq", metadata !"fpexcept.strict") #[[ATTR5]] [ "fp.except"(metadata !"strict") ]
 // CHECK-NEXT:    br i1 [[ISINF]], label [[FPCLASSIFY_END]], label [[FPCLASSIFY_NOT_INF]]
 // CHECK:       fpclassify_not_inf:
-// CHECK-NEXT:    [[ISNORMAL:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f64(double [[TMP1]], double 0x10000000000000, metadata !"uge", metadata !"fpexcept.strict") #[[ATTR5]] [ "fpe.except"(metadata !"strict") ]
+// CHECK-NEXT:    [[ISNORMAL:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f64(double [[TMP1]], double 0x10000000000000, metadata !"uge", metadata !"fpexcept.strict") #[[ATTR5]] [ "fp.except"(metadata !"strict") ]
 // CHECK-NEXT:    [[TMP2]] = select i1 [[ISNORMAL]], i32 2, i32 3
 // CHECK-NEXT:    br label [[FPCLASSIFY_END]]
 //
@@ -157,7 +157,7 @@ void test_double_isfinite(double d) {
 // CHECK-NEXT:    store double [[D:%.*]], ptr [[D_ADDR]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load double, ptr [[D_ADDR]], align 8
 // CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.fabs.f64(double [[TMP0]]) #[[ATTR6]]
-// CHECK-NEXT:    [[ISINF:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f64(double [[TMP1]], double 0x7FF0000000000000, metadata !"oeq", metadata !"fpexcept.strict") #[[ATTR5]] [ "fpe.except"(metadata !"strict") ]
+// CHECK-NEXT:    [[ISINF:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f64(double [[TMP1]], double 0x7FF0000000000000, metadata !"oeq", metadata !"fpexcept.strict") #[[ATTR5]] [ "fp.except"(metadata !"strict") ]
 // CHECK-NEXT:    [[TMP2:%.*]] = bitcast double [[TMP0]] to i64
 // CHECK-NEXT:    [[TMP3:%.*]] = icmp slt i64 [[TMP2]], 0
 // CHECK-NEXT:    [[TMP4:%.*]] = select i1 [[TMP3]], i32 -1, i32 1

clang/test/CodeGenOpenCL/cl20-device-side-enqueue-attributes.cl

@@ -144,7 +144,7 @@ kernel void device_side_enqueue(global float *a, global float *b, int i) {
 // STRICTFP-NEXT:    [[TMP1:%.*]] = load i32, ptr addrspace(4) [[BLOCK_CAPTURE_ADDR1]], align 4
 // STRICTFP-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, ptr addrspace(1) [[TMP0]], i32 [[TMP1]]
 // STRICTFP-NEXT:    [[TMP2:%.*]] = load float, ptr addrspace(1) [[ARRAYIDX]], align 4
-// STRICTFP-NEXT:    [[TMP3:%.*]] = call float @llvm.experimental.constrained.fmuladd.f32(float 4.000000e+00, float [[TMP2]], float 1.000000e+00, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR6:[0-9]+]] [ "fpe.control"(metadata !"rte"), "fpe.except"(metadata !"strict") ]
+// STRICTFP-NEXT:    [[TMP3:%.*]] = call float @llvm.experimental.constrained.fmuladd.f32(float 4.000000e+00, float [[TMP2]], float 1.000000e+00, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR6:[0-9]+]] [ "fp.control"(metadata !"rte"), "fp.except"(metadata !"strict") ]
 // STRICTFP-NEXT:    [[BLOCK_CAPTURE_ADDR2:%.*]] = getelementptr inbounds nuw <{ i32, i32, ptr addrspace(4), ptr addrspace(1), i32, ptr addrspace(1) }>, ptr addrspace(4) [[DOTBLOCK_DESCRIPTOR]], i32 0, i32 3
 // STRICTFP-NEXT:    [[TMP4:%.*]] = load ptr addrspace(1), ptr addrspace(4) [[BLOCK_CAPTURE_ADDR2]], align 4
 // STRICTFP-NEXT:    [[BLOCK_CAPTURE_ADDR3:%.*]] = getelementptr inbounds nuw <{ i32, i32, ptr addrspace(4), ptr addrspace(1), i32, ptr addrspace(1) }>, ptr addrspace(4) [[DOTBLOCK_DESCRIPTOR]], i32 0, i32 4

llvm/docs/LangRef.rst

@@ -3068,7 +3068,7 @@ depend on floating-point options, such as rounding mode, denormal modes, etc.
 There are two kinds of such operand bundles, which represent the value of
 floating-point control modes and the treatment of status bits respectively.
 
-An operand bundle tagged with "fpe.control" contains information about the
+An operand bundle tagged with "fp.control" contains information about the
 control modes used for the operation execution. Currently, only rounding mode is
 supported. It is represented by a metadata string value, which specifies the
 rounding mode to be used for the operation evaluation. Possible values are:
@@ -3082,12 +3082,12 @@ rounding mode to be used for the operation evaluation. Possible values are:
     "rmm"  - to nearest, ties away from zero
     "dyn"  - rounding mode is taken from control register
 
-If "fpe.control" is absent, the default rounding rounding mode is taken from the
+If "fp.control" is absent, the default rounding rounding mode is taken from the
 control register (dynamic rounding). In the particular case of
 :ref:`default floating-point environment <floatenv>`, it must be rounding to
 nearest, ties to even.
 
-An operand bundle tagged with "fpe.except" may be associated with operations
+An operand bundle tagged with "fp.except" may be associated with operations
 that can read or write floating-point exception flags. It contains a single
 metadata string value, which can have one of the following values:
 

llvm/include/llvm/IR/LLVMContext.h

@@ -96,8 +96,8 @@ class LLVMContext {
     OB_ptrauth = 7,                // "ptrauth"
     OB_kcfi = 8,                   // "kcfi"
     OB_convergencectrl = 9,        // "convergencectrl"
-    OB_fpe_control = 10,           // "fpe.control"
-    OB_fpe_except = 11,            // "fpe.except"
+    OB_fp_control = 10,            // "fp.control"
+    OB_fp_except = 11,             // "fp.except"
   };
 
   /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.

llvm/lib/AsmParser/LLParser.cpp

@@ -6430,7 +6430,7 @@ void LLParser::updateConstrainedIntrinsic(
     return;
 
   for (auto &B : Bundles) {
-    if (B.getTag().starts_with("fpe."))
+    if (B.getTag().starts_with("fp."))
       return;
   }
 

llvm/lib/IR/IRBuilder.cpp

@@ -102,9 +102,9 @@ CallInst *IRBuilderBase::CreateCall(FunctionType *FTy, Value *Callee,
           bool NeedRound = true, NeedExcept = true;
           doesCallAccessFPEnv = true;
           for (const auto &Item : OpBundles) {
-            if (NeedRound && Item.getTag() == "fpe.control")
+            if (NeedRound && Item.getTag() == "fp.control")
               NeedRound = false;
-            else if (NeedExcept && Item.getTag() == "fpe.except")
+            else if (NeedExcept && Item.getTag() == "fp.except")
               NeedExcept = false;
             ActualBundles.push_back(Item);
           }

llvm/lib/IR/Instructions.cpp

@@ -622,7 +622,7 @@ bool CallBase::hasClobberingOperandBundles() const {
 }
 
 std::optional<RoundingMode> CallBase::getRoundingMode() const {
-  if (auto RoundingBundle = getOperandBundle(LLVMContext::OB_fpe_control)) {
+  if (auto RoundingBundle = getOperandBundle(LLVMContext::OB_fp_control)) {
     Value *V = RoundingBundle->Inputs.front();
     Metadata *MD = cast<MetadataAsValue>(V)->getMetadata();
     return convertStrToRoundingMode(cast<MDString>(MD)->getString(), true);
@@ -631,7 +631,7 @@ std::optional<RoundingMode> CallBase::getRoundingMode() const {
 }
 
 std::optional<fp::ExceptionBehavior> CallBase::getExceptionBehavior() const {
-  if (auto ExceptionBundle = getOperandBundle(LLVMContext::OB_fpe_except)) {
+  if (auto ExceptionBundle = getOperandBundle(LLVMContext::OB_fp_except)) {
     Value *V = ExceptionBundle->Inputs.front();
     Metadata *MD = cast<MetadataAsValue>(V)->getMetadata();
     return convertStrToExceptionBehavior(cast<MDString>(MD)->getString(), true);
@@ -640,8 +640,8 @@ std::optional<fp::ExceptionBehavior> CallBase::getExceptionBehavior() const {
 }
 
 bool CallBase::hasFloatingPointBundles() const {
-  return getOperandBundle(LLVMContext::OB_fpe_control) ||
-         getOperandBundle(LLVMContext::OB_fpe_except);
+  return getOperandBundle(LLVMContext::OB_fp_control) ||
+         getOperandBundle(LLVMContext::OB_fp_except);
 }
 
 MemoryEffects CallBase::getFloatingPointMemoryEffects() const {
@@ -767,7 +767,7 @@ void llvm::addFPRoundingBundle(LLVMContext &Ctx,
   assert(RndStr && "Garbage rounding mode!");
   auto *RoundingMDS = MDString::get(Ctx, *RndStr);
   auto *RM = MetadataAsValue::get(Ctx, RoundingMDS);
-  Bundles.emplace_back("fpe.control", RM);
+  Bundles.emplace_back("fp.control", RM);
 }
 
 void llvm::addFPExceptionBundle(LLVMContext &Ctx,
@@ -777,7 +777,7 @@ void llvm::addFPExceptionBundle(LLVMContext &Ctx,
   assert(ExcStr && "Garbage exception behavior!");
   auto *ExceptMDS = MDString::get(Ctx, *ExcStr);
   auto *EB = MetadataAsValue::get(Ctx, ExceptMDS);
-  Bundles.emplace_back("fpe.except", EB);
+  Bundles.emplace_back("fp.except", EB);
 }
 
 //===----------------------------------------------------------------------===//

llvm/lib/IR/LLVMContext.cpp

@@ -82,14 +82,14 @@ LLVMContext::LLVMContext() : pImpl(new LLVMContextImpl(*this)) {
     assert(Entry->second == BundleTagID && "operand bundle id drifted!");
   }
 
-  auto *RoundingEntry = pImpl->getOrInsertBundleTag("fpe.control");
-  assert(RoundingEntry->second == LLVMContext::OB_fpe_control &&
-         "fpe.control operand bundle id drifted!");
+  auto *RoundingEntry = pImpl->getOrInsertBundleTag("fp.control");
+  assert(RoundingEntry->second == LLVMContext::OB_fp_control &&
+         "fp.control operand bundle id drifted!");
   (void)RoundingEntry;
 
-  auto *ExceptionEntry = pImpl->getOrInsertBundleTag("fpe.except");
-  assert(ExceptionEntry->second == LLVMContext::OB_fpe_except &&
-         "fpe.except operand bundle id drifted!");
+  auto *ExceptionEntry = pImpl->getOrInsertBundleTag("fp.except");
+  assert(ExceptionEntry->second == LLVMContext::OB_fp_except &&
+         "fp.except operand bundle id drifted!");
   (void)ExceptionEntry;
 
   SyncScope::ID SingleThreadSSID =

llvm/lib/IR/Verifier.cpp

@@ -3796,32 +3796,31 @@ void Verifier::visitCallBase(CallBase &Call) {
             "Multiple \"clang.arc.attachedcall\" operand bundles", Call);
       FoundAttachedCallBundle = true;
       verifyAttachedCallBundle(Call, BU);
-    } else if (Tag == LLVMContext::OB_fpe_control) {
-      Check(!FoundFpeControlBundle, "Multiple fpe.control operand bundles",
+    } else if (Tag == LLVMContext::OB_fp_control) {
+      Check(!FoundFpeControlBundle, "Multiple fp.control operand bundles",
             Call);
       Check(BU.Inputs.size() == 1,
-            "Expected exactly one fpe.control bundle operand", Call);
+            "Expected exactly one fp.control bundle operand", Call);
       auto *V = dyn_cast<MetadataAsValue>(BU.Inputs.front());
-      Check(V, "Value of fpe.control bundle operand must be a metadata", Call);
+      Check(V, "Value of fp.control bundle operand must be a metadata", Call);
       auto *MDS = dyn_cast<MDString>(V->getMetadata());
-      Check(MDS, "Value of fpe.control bundle operand must be a string", Call);
+      Check(MDS, "Value of fp.control bundle operand must be a string", Call);
       auto RM = convertStrToRoundingMode(MDS->getString(), true);
-      Check(
-          RM.has_value(),
-          "Value of fpe.control bundle operand is not a correct rounding mode",
-          Call);
+      Check(RM.has_value(),
+            "Value of fp.control bundle operand is not a correct rounding mode",
+            Call);
       FoundFpeControlBundle = true;
-    } else if (Tag == LLVMContext::OB_fpe_except) {
-      Check(!FoundFpeExceptBundle, "Multiple fpe.except operand bundles", Call);
+    } else if (Tag == LLVMContext::OB_fp_except) {
+      Check(!FoundFpeExceptBundle, "Multiple fp.except operand bundles", Call);
       Check(BU.Inputs.size() == 1,
-            "Expected exactly one fpe.except bundle operand", Call);
+            "Expected exactly one fp.except bundle operand", Call);
       auto *V = dyn_cast<MetadataAsValue>(BU.Inputs.front());
-      Check(V, "Value of fpe.except bundle operand must be a metadata", Call);
+      Check(V, "Value of fp.except bundle operand must be a metadata", Call);
       auto *MDS = dyn_cast<MDString>(V->getMetadata());
-      Check(MDS, "Value of fpe.except bundle operand must be a string", Call);
+      Check(MDS, "Value of fp.except bundle operand must be a string", Call);
       auto EB = convertStrToExceptionBehavior(MDS->getString(), true);
       Check(EB.has_value(),
-            "Value of fpe.except bundle operand is not a correct exception "
+            "Value of fp.except bundle operand is not a correct exception "
             "behavior",
             Call);
       FoundFpeExceptBundle = true;
@@ -3867,7 +3866,7 @@ void Verifier::verifyConstrainedInstrinsicCall(const CallBase &CB) {
   // operand bundles.
   if (std::optional<RoundingMode> RM = getRoundingModeArg(CB)) {
     RoundingMode Rounding = *RM;
-    auto RoundingBundle = CB.getOperandBundle(LLVMContext::OB_fpe_control);
+    auto RoundingBundle = CB.getOperandBundle(LLVMContext::OB_fp_control);
     Check(RoundingBundle,
           "Constrained intrinsic has a rounding argument but the call does not",
           CB);
@@ -3885,7 +3884,7 @@ void Verifier::verifyConstrainedInstrinsicCall(const CallBase &CB) {
 
   if (std::optional<fp::ExceptionBehavior> EB = getExceptionBehaviorArg(CB)) {
     fp::ExceptionBehavior Excepts = *EB;
-    auto ExceptionBundle = CB.getOperandBundle(LLVMContext::OB_fpe_except);
+    auto ExceptionBundle = CB.getOperandBundle(LLVMContext::OB_fp_except);
     Check(ExceptionBundle,
           "Constrained intrinsic has an exception handling argument but the "
           "call does not",

llvm/lib/Transforms/Scalar/TailRecursionElimination.cpp

@@ -256,7 +256,7 @@ static bool markTails(Function &F, OptimizationRemarkEmitter *ORE) {
                LLVMContext::OB_kcfi,
                // A call with FP operand bundles should be treated in the same
                // way as a call without them.
-               LLVMContext::OB_fpe_control, LLVMContext::OB_fpe_except});
+               LLVMContext::OB_fp_control, LLVMContext::OB_fp_except});
 
       if (!IsNoTail && CI->doesNotAccessMemory()) {
         // A call to a readnone function whose arguments are all things computed