[FEnv] Small fixes to implementation of flt.rounds

[sepavloff]

Summary

This change makes assorted correction related to the intrinsic
llvm.flt.rounds:

• Added documentation entry in LangRef,
• Attributes of the intrinsic changed to be in line with other functions dependent of floating-point environment,

[sepavloff]

Updated patch

• rebased,
• corrected documentation,
• fixed formatting.

[lenary]

llvm/test/CodeGen/RISCV/flt-rounds.ll

23

I'm interested to understand how this function is provided. Is it part of compiler-rt or libgcc, or is it provided another way?

[sepavloff]

llvm/test/CodeGen/RISCV/flt-rounds.ll

23

At least musl library provides its implementation: https://git.musl-libc.org/cgit/musl/tree/src/fenv/__flt_rounds.c . Similar implementation exists in glibc.

[craig.topper]

llvm/test/CodeGen/RISCV/flt-rounds.ll

23

A quick google search for "glibc __flt_rounds" only shows it in a powerpc nofpu file.

[sepavloff]

Updated patch

Default lowering of FLT_ROUNDS_ again is made by replacing the node with
constant 1, which denotes rounding to nearest, ties to even. It is incorrect,
but is compatible with with current behavior. Using more correct lowering to
function call may cause problems for targents that rely on default lowering,
because not all C standard libraries implements __flt_rounds.

[sepavloff]

llvm/test/CodeGen/RISCV/flt-rounds.ll

23

GCC defined FLT_ROUNDS in float.h as 1, which is incorrect in general case. As for __builtin_flt_rounds, now GCC does not have such intrinsic. So using FLT_ROUND on some targets might be tied to this kludge and lowering it to function call can cause fails. So lowering to a constant was restored.

[sepavloff]

Updated patch

• Removed support for lowering to library call at all. Now it is NFC patch.

[craig.topper]

LGTM

clang/include/clang/Basic/Builtins.def

 BUILTIN(__builtin_tgamma , "dd", "Fne")
 BUILTIN(__builtin_tgammaf, "ff", "Fne")
 BUILTIN(__builtin_tgammal, "LdLd", "Fne")
 BUILTIN(__builtin_trunc , "dd", "Fnc")
 BUILTIN(__builtin_truncf, "ff", "Fnc")
 BUILTIN(__builtin_truncl, "LdLd", "Fnc")
 BUILTIN(__builtin_truncf16, "hh", "Fnc")
 
+// Access to floating point environment
+BUILTIN(__builtin_flt_rounds, "i", "n")
+
 // C99 complex builtins
 BUILTIN(__builtin_cabs, "dXd", "Fne")
 BUILTIN(__builtin_cabsf, "fXf", "Fne")
 BUILTIN(__builtin_cabsl, "LdXLd", "Fne")
 BUILTIN(__builtin_cacos, "XdXd", "Fne")
 BUILTIN(__builtin_cacosf, "XfXf", "Fne")
 BUILTIN(__builtin_cacosh, "XdXd", "Fne")
 BUILTIN(__builtin_cacoshf, "XfXf", "Fne")

 BUILTIN(__builtin_wmemchr, "w*wC*wz", "nF")
 BUILTIN(__builtin_wmemcmp, "iwC*wC*z", "nF")
 BUILTIN(__builtin_wmemcpy, "w*w*wC*z", "nF")
 BUILTIN(__builtin_wmemmove, "w*w*wC*z", "nF")
 BUILTIN(__builtin_return_address, "v*IUi", "n")
 BUILTIN(__builtin_extract_return_addr, "v*v*", "n")
 BUILTIN(__builtin_frame_address, "v*IUi", "n")
 BUILTIN(__builtin___clear_cache, "vc*c*", "n")
-BUILTIN(__builtin_flt_rounds, "i", "nc")
+BUILTIN(__builtin_flt_rounds, "i", "n")
 BUILTIN(__builtin_setjmp, "iv**", "j")
 BUILTIN(__builtin_longjmp, "vv**i", "r")
 BUILTIN(__builtin_unwind_init, "v", "")
 BUILTIN(__builtin_eh_return_data_regno, "iIi", "nc")
 BUILTIN(__builtin_snprintf, "ic*zcC*.", "nFp:2:")
 BUILTIN(__builtin_vsprintf, "ic*cC*a", "nFP:1:")
 BUILTIN(__builtin_vsnprintf, "ic*zcC*a", "nFP:2:")
 BUILTIN(__builtin_thread_pointer, "v*", "nc")

llvm/docs/LangRef.rst

 
 Semantics:
 """"""""""
 
 This function returns the same values as the libm ``trunc`` functions
 would and handles error conditions in the same way.
 
 
+Floating Point Environment Manipulation intrinsics
+--------------------------------------------------
+
+These functions read or write floating point environment, such as rounding
+mode or state of floating point exceptions. Altering the floating point
+environment requires special care. See :ref:`Floating Point Environment <floatenv>`.
+
+'``llvm.flt.rounds``' Intrinsic
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Syntax:
+"""""""
+
+::
+
+      declare i32 @llvm.flt.rounds()
+
+Overview:
+"""""""""
+
+The '``llvm.flt.rounds``' intrinsic reads current rounding mode.
+
+Semantics:
+""""""""""
+
+The '``llvm.flt.rounds``' intrinsic returns the current rounding mode.
+Encoding of the returned values is same as the result of ``FLT_ROUNDS``,
+specified by C standard:
+
+::
+
+    0  - toward zero
+    1  - to nearest, ties to even
+    2  - toward positive infinity
+    3  - toward negative infinity
+    4  - to nearest, ties away from zero
+
+Other values may be used to represent additional rounding modes, supported by a
+target. These values are target-specific.
+
 General Intrinsics
 ------------------
 
 This class of intrinsics is designed to be generic and has no specific
 purpose.
 
 '``llvm.var.annotation``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

llvm/include/llvm/IR/Intrinsics.td

 
 // Internal interface for object size checking
 def int_objectsize : Intrinsic<[llvm_anyint_ty],
                                [llvm_anyptr_ty, llvm_i1_ty,
                                 llvm_i1_ty, llvm_i1_ty],
                                [IntrNoMem, IntrSpeculatable, IntrWillReturn, ImmArg<1>, ImmArg<2>, ImmArg<3>]>,
                                GCCBuiltin<"__builtin_object_size">;
 
+//===--------------- Access to Floating Point Environment -----------------===//
+//
+
+let IntrProperties = [IntrInaccessibleMemOnly, IntrWillReturn] in {
+  def int_flt_rounds    : Intrinsic<[llvm_i32_ty], []>,
+                          GCCBuiltin<"__builtin_flt_rounds">;
+}
+
 //===--------------- Constrained Floating Point Intrinsics ----------------===//
 //
 
 let IntrProperties = [IntrInaccessibleMemOnly, IntrWillReturn] in {
   def int_experimental_constrained_fadd : Intrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       LLVMMatchType<0>,
                                                       llvm_metadata_ty,

 // Coroutine Lowering Intrinsics. Used internally by coroutine passes.
 
 def int_coro_subfn_addr : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_i8_ty],
                                     [IntrReadMem, IntrArgMemOnly, ReadOnly<0>,
                                      NoCapture<0>]>;
 
 ///===-------------------------- Other Intrinsics --------------------------===//
 //
-def int_flt_rounds : Intrinsic<[llvm_i32_ty]>,
-                     GCCBuiltin<"__builtin_flt_rounds">;
 def int_trap : Intrinsic<[], [], [IntrNoReturn, IntrCold]>,
                GCCBuiltin<"__builtin_trap">;
 def int_debugtrap : Intrinsic<[]>,
                     GCCBuiltin<"__builtin_debugtrap">;
 
 // Support for dynamic deoptimization (or de-specialization)
 def int_experimental_deoptimize : Intrinsic<[llvm_any_ty], [llvm_vararg_ty],
                                             [Throws]>;

llvm/include/llvm/IR/RuntimeLibcalls.def

 HANDLE_LIBCALL(STACKPROTECTOR_CHECK_FAIL, "__stack_chk_fail")
 
 // Deoptimization
 HANDLE_LIBCALL(DEOPTIMIZE, "__llvm_deoptimize")
 
 // Return address
 HANDLE_LIBCALL(RETURN_ADDRESS, nullptr)
 
+// Floating-point Environment
+HANDLE_LIBCALL(FLT_ROUNDS_, "__flt_rounds")
+
 HANDLE_LIBCALL(UNKNOWN_LIBCALL, nullptr)
 
 #undef HANDLE_LIBCALL

llvm/lib/CodeGen/IntrinsicLowering.cpp

case Intrinsic::round: {
     ReplaceFPIntrinsicWithCall(CI, "roundf", "round", "roundl");
     break;
   }
   case Intrinsic::copysign: {
     ReplaceFPIntrinsicWithCall(CI, "copysignf", "copysign", "copysignl");
     break;
   }
   case Intrinsic::flt_rounds:
-     // Lower to "round to the nearest"
-     if (!CI->getType()->isVoidTy())
-       CI->replaceAllUsesWith(ConstantInt::get(CI->getType(), 1));
-     break;
+    ReplaceCallWith("__flt_rounds", CI, CI->arg_begin(), CI->arg_end(),
+                    Type::getInt32Ty(CI->getContext()));
   case Intrinsic::invariant_start:
   case Intrinsic::lifetime_start:
     // Discard region information.
     CI->replaceAllUsesWith(UndefValue::get(CI->getType()));
     break;
   case Intrinsic::invariant_end:
   case Intrinsic::lifetime_end:
     // Discard region information.

llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

SDValue Offset = DAG.getNode(ISD::ADD, dl,
                                  CfaArg);
     SDValue FA = DAG.getNode(
         ISD::FRAMEADDR, dl, TLI.getPointerTy(DAG.getDataLayout()),
         DAG.getConstant(0, dl, TLI.getPointerTy(DAG.getDataLayout())));
     Results.push_back(DAG.getNode(ISD::ADD, dl, FA.getValueType(),
                                   FA, Offset));
     break;
   }
-  case ISD::FLT_ROUNDS_:
-    Results.push_back(DAG.getConstant(1, dl, Node->getValueType(0)));
-    Results.push_back(Node->getOperand(0));
+  case ISD::FLT_ROUNDS_: {
+    EVT RetVT = Node->getValueType(0);
+    TargetLowering::MakeLibCallOptions CallOptions;
+    std::pair<SDValue, SDValue> Tmp =
+        TLI.makeLibCall(DAG, RTLIB::FLT_ROUNDS_, RetVT, None, CallOptions,
+                        SDLoc(Node), Node->getOperand(0));
+    Results.push_back(Tmp.first);
+    Results.push_back(Tmp.second);
     break;
+  }
   case ISD::EH_RETURN:
   case ISD::EH_LABEL:
   case ISD::PREFETCH:
   case ISD::VAEND:
   case ISD::EH_SJLJ_LONGJMP:
     // If the target didn't expand these, there's nothing to do, so just
     // preserve the chain and be done.
     Results.push_back(Node->getOperand(0));

llvm/test/CodeGen/MSP430/flt_rounds.ll

-; RUN: llc -verify-machineinstrs < %s -march=msp430
+; RUN: llc -verify-machineinstrs -march=msp430 < %s | FileCheck %s
 
 define i16 @foo() {
 entry:
   %0 = call i32 @llvm.flt.rounds()
   %1 = trunc i32 %0 to i16
   ret i16 %1
 }
 
 declare i32 @llvm.flt.rounds() nounwind 
+
+; CHECK: call #__flt_rounds

llvm/test/CodeGen/RISCV/flt-rounds.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -mtriple=riscv32 -verify-machineinstrs < %s \
 ; RUN:   | FileCheck -check-prefix=RV32I %s
 ; RUN: llc -mtriple=riscv64 -verify-machineinstrs < %s \
 ; RUN:   | FileCheck -check-prefix=RV64I %s
 
 declare i32 @llvm.flt.rounds()
 
 define i32 @test_flt_rounds() nounwind {
 ; RV32I-LABEL: test_flt_rounds:
 ; RV32I:       # %bb.0:
-; RV32I-NEXT:    addi a0, zero, 1
+; RV32I-NEXT:    addi sp, sp, -16
+; RV32I-NEXT:    sw ra, 12(sp)
+; RV32I-NEXT:    call __flt_rounds
+; RV32I-NEXT:    lw ra, 12(sp)
+; RV32I-NEXT:    addi sp, sp, 16
 ; RV32I-NEXT:    ret
 ;
 ; RV64I-LABEL: test_flt_rounds:
 ; RV64I:       # %bb.0:
-; RV64I-NEXT:    addi a0, zero, 1
+; RV64I-NEXT:    addi sp, sp, -16
+; RV64I-NEXT:    sd ra, 8(sp)
+; RV64I-NEXT:    call __flt_rounds
+; RV64I-NEXT:    ld ra, 8(sp)
+; RV64I-NEXT:    addi sp, sp, 16
 ; RV64I-NEXT:    ret
   %1 = call i32 @llvm.flt.rounds()
   ret i32 %1
 }