Add __builtin_set_flt_rounds

[xiongji90]

Summary

This builtin will be converted to llvm.set.rounding intrinsic in IR level and should be work with "#pragma STDC FENV_ACCESS ON" since it changes default FP environment. Users can change rounding mode via this builtin without introducing libc dependency.
This patch re-lands https://reviews.llvm.org/rG24b823554acd25009731b2519880aa18c7263550 , previous patch fails due to a test case bug. The builtin "__builtin_set_flt_rounds" are restricted to work only on x86, x86_64, arm target but previous test is in builtin.c which will run on other targets such ppc64, so it breaks other targets' build. The new patch moves the test to a separate file and use "-triple x86_64-gnu-linux", "-triple x86_64-windows-msvc", "-triple aarch64-gnu-linux", "-triple aarch64-windows-msvc" to run the lit test

[xiongji90]

Hi, @andrew.w.kaylor @rjmccall @sepavloff @aaron.ballman
This patch re-lands previous patch to add builtin_set_flt_rounds, previous patch broke PPC64 buildbot due to test case bug. Previously, tests for builtin_set_flt_rounds was located in CodeGen/builtin.c which would run on all triples but this builtin was restricted to work only on Intel and Arm platform, so the builtin.c will fail on targets such as PPC64. I move the test into a separate file and use following commands to run the lit test:
RUN: %clang_cc1 -triple x86_64-gnu-linux %s -emit-llvm -o - | FileCheck %s
RUN: %clang_cc1 -triple x86_64-windows-msvc %s -emit-llvm -o - | FileCheck %s
RUN: %clang_cc1 -triple aarch64-gnu-linux %s -emit-llvm -o - | FileCheck %s
RUN: %clang_cc1 -triple aarch64-windows-msvc %s -emit-llvm -o - | FileCheck %s
Could you help review again?

[aaron.ballman]

Thank you for this! You should also add a release note and some documentation for the new builtin.

clang/test/CodeGen/builtin_set_flt_rounds.c

2–5

Minor cleanup.

6–8

I think you should also add some Sema tests for correct and misuse of the builtin:

__builtin_set_flt_rounds(1); // OK

struct S { int a; } s;
__builtin_set_flt_rounds(s); // This should diagnose, right?

__builtin_set_flt_rounds(1.0f); // Should this implicitly convert or is this an error?

and that sema test can additionally test what happens when you call the builtin on an unsupported architecture.

[xiongji90]

Add semachecking test for unsupported platform.

[xiongji90]

clang/test/CodeGen/builtin_set_flt_rounds.c

6–8

Hi, @aaron.ballman
I added a new test in test/Sema to check the builtin on platforms unsupported.
Thanks very much.

[xiongji90]

Add SemaChecking test for incompatible input arguments for __builtin_set_flt_rounds.

[aaron.ballman]

Thanks for the additional tests! Can you also add a release note to clang/docs/ReleaseNotes.rst and document the new builtin in clang\docs\LanguageExtensions.rst?

clang/test/Sema/builtin_set_flt_rounds.c

2–12

Simplify the test somewhat.

[xiongji90]

Simplify test and update release doc

[xiongji90]

In D145765#4189153, @aaron.ballman wrote:

Thanks for the additional tests! Can you also add a release note to clang/docs/ReleaseNotes.rst and document the new builtin in clang\docs\LanguageExtensions.rst?

Hi, @aaron.ballman
I have simplified the test as you suggested and I also updated release doc to add "builtin_set_flt_rounds" in fp support section. To LanguageExtension.rst, I prefer to creating a patch since we already had another builtin "builtin_flt_rounds" which was not documented, I plan to document these 2 builtin together.
Thanks very much.

[aaron.ballman]

In D145765#4191800, @xiongji90 wrote:

I have simplified the test as you suggested and I also updated release doc to add "builtin_set_flt_rounds" in fp support section. To LanguageExtension.rst, I prefer to creating a patch since we already had another builtin "builtin_flt_rounds" which was not documented, I plan to document these 2 builtin together.

Documenting the two builtins together in a follow-up patch sounds fine to me, thank you!

LGTM

clang/docs/ReleaseNotes.rst

 
 Floating Point Support in Clang
 -------------------------------
 - Add ``__builtin_elementwise_log`` builtin for floating point types only.
 - Add ``__builtin_elementwise_log10`` builtin for floating point types only.
 - Add ``__builtin_elementwise_log2`` builtin for floating point types only.
 - Add ``__builtin_elementwise_exp`` builtin for floating point types only.
 - Add ``__builtin_elementwise_exp2`` builtin for floating point types only.
+- Add ``__builtin_set_flt_rounds`` builtin for X86, x86_64, Arm and AArch64 only.
 
 AST Matchers
 ------------
 
 - Add ``coroutineBodyStmt`` matcher.
 
 - The ``hasBody`` matcher now matches coroutine body nodes in
   ``CoroutineBodyStmts``.

clang/include/clang/Basic/Builtins.def

 BUILTIN(__builtin_trunc , "dd", "Fnc")
 BUILTIN(__builtin_truncf, "ff", "Fnc")
 BUILTIN(__builtin_truncl, "LdLd", "Fnc")
 BUILTIN(__builtin_truncf128, "LLdLLd", "Fnc")
 BUILTIN(__builtin_truncf16, "hh", "Fnc")
 
 // Access to floating point environment
 BUILTIN(__builtin_flt_rounds, "i", "n")
+BUILTIN(__builtin_set_flt_rounds, "vi", "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")

clang/lib/CodeGen/CGBuiltin.cpp

case Builtin::BI__builtin_flt_rounds: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Value *Result = Builder.CreateCall(F);
     if (Result->getType() != ResultType)
       Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
                                      "cast");
     return RValue::get(Result);
   }
 
+  case Builtin::BI__builtin_set_flt_rounds: {
+    Function *F = CGM.getIntrinsic(Intrinsic::set_rounding);
+
+    Value *V = EmitScalarExpr(E->getArg(0));
+    Builder.CreateCall(F, V);
+    return RValue::get(nullptr);
+  }
+
   case Builtin::BI__builtin_fpclassify: {
     CodeGenFunction::CGFPOptionsRAII FPOptsRAII(*this, E);
     // FIXME: for strictfp/IEEE-754 we need to not trap on SNaN here.
     Value *V = EmitScalarExpr(E->getArg(5));
     llvm::Type *Ty = ConvertType(E->getArg(5)->getType());
 
     // Create Result
     BasicBlock *Begin = Builder.GetInsertBlock();

clang/lib/Sema/SemaChecking.cpp

Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
   case Builtin::BI_interlockedbittestandset64:
     if (CheckBuiltinTargetInSupported(*this, BuiltinID, TheCall,
                                       {llvm::Triple::x86_64, llvm::Triple::arm,
                                        llvm::Triple::thumb,
                                        llvm::Triple::aarch64}))
       return ExprError();
     break;
 
+  case Builtin::BI__builtin_set_flt_rounds:
+    if (CheckBuiltinTargetInSupported(*this, BuiltinID, TheCall,
+                                      {llvm::Triple::x86, llvm::Triple::x86_64,
+                                       llvm::Triple::arm, llvm::Triple::thumb,
+                                       llvm::Triple::aarch64}))
+      return ExprError();
+    break;
+
   case Builtin::BI__builtin_isgreater:
   case Builtin::BI__builtin_isgreaterequal:
   case Builtin::BI__builtin_isless:
   case Builtin::BI__builtin_islessequal:
   case Builtin::BI__builtin_islessgreater:
   case Builtin::BI__builtin_isunordered:
     if (SemaBuiltinUnorderedCompare(TheCall))
       return ExprError();

clang/test/CodeGen/builtin_set_flt_rounds.c

+// RUN: %clang_cc1 -triple x86_64-gnu-linux %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-windows-msvc %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple aarch64-gnu-linux %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple aarch64-windows-msvc %s -emit-llvm -o - | FileCheck %s
+void test_builtin_set_flt_rounds() {
+  __builtin_set_flt_rounds(1);
+  // CHECK: call void @llvm.set.rounding(i32 1)
+}

clang/test/Sema/builtin_set_flt_rounds.c

+// RUN: %clang_cc1 -triple mipsel-unknown-linux -fsyntax-only %s -verify=expected,unsupported
+// RUN: %clang_cc1 -triple x86_64-gnu-linux -fsyntax-only %s -verify
+struct S {int a;};
+void test_builtin_set_flt_rounds() {
+  __builtin_set_flt_rounds(1); // unsupported-error {{builtin is not supported on this target}}
+  struct S s;
+  __builtin_set_flt_rounds(s); // expected-error {{passing 'struct S' to parameter of incompatible type}}
+}