Add builtin_elementwise_sin and builtin_elementwise_cos

[bob80905]

Summary

Add codegen for llvm cos and sin elementwise builtins
The sin and cos elementwise builtins are necessary for HLSL codegen.
Tests were added to make sure that the expected errors are encountered when these functions are given inputs of incompatible types.
The new builtins are restricted to floating point types only.

[bob80905]

rever format commit

[bob80905]

• make format consistent, update test copy mistake

[bob80905]

run git clang-format on changes rather than whole document

[fhahn]

Could you update the title to make it clear this adds new Clang builtins, not intrinsics (they are lowered to LLVM intrinsics). The behavior of the new builtins should be specified in LanguageExtensions.rst (https://clang.llvm.org/docs/LanguageExtensions.html#vector-builtins)

[erichkeane]

Please clarify the commit message (review description) to better explain what it is you're doing here, the purpose/etc as well as the documentation requested by @fhahn

This also needs release notes.

clang/test/SemaCXX/builtins-elementwise-math.cpp

76

Nit: please make sure this newline is present.

[bob80905]

• add docs, add new line

[bob80905]

• add release note

[craig.topper]

Does these support scalable vector types from ARM SVE or RISC-V? I can't remember what the rest of the __builtin_elementwise do. I ask because the backends will probably crash for them.

[rjmccall]

The titled of this patch should be something like "Add builtin_elementwise_sin and builtin_elementwise_cos".

Can you explain why this uses a new builtin name instead of overloading the existing builtins to work on vectors? I can imagine reasons why, but I think it needs to be explained. I can't imagine cos and sin not being element-wise operations on a vector.

[python3kgae]

In D135011#3831949, @rjmccall wrote:

The titled of this patch should be something like "Add builtin_elementwise_sin and builtin_elementwise_cos".

Can you explain why this uses a new builtin name instead of overloading the existing builtins to work on vectors? I can imagine reasons why, but I think it needs to be explained. I can't imagine cos and sin not being element-wise operations on a vector.

It just adds additional builtins following the other vector-wise builtins.
As mentioned in https://lists.llvm.org/pipermail/cfe-dev/2021-September/068999.html, it is much easier to just use one builtin for all overloads instead of using different builtins for different overloads.

[rjmccall]

Ah, I'd forgotten we had a bunch of elementwise builtins already. I wouldn't be surprised if I asked for that in that patch, actually, especially because the existing ones include some functions like max and min where you could easily imagine them being cross-lane. Nevermind.

[python3kgae]

In D135011#3831452, @craig.topper wrote:

Does these support scalable vector types from ARM SVE or RISC-V? I can't remember what the rest of the __builtin_elementwise do. I ask because the backends will probably crash for them.

checkMathBuiltinElementType should stop scalable vector types in Sema::CheckBuiltinFunctionCall.

[bob80905]

In D135011#3831452, @craig.topper wrote:

Does these support scalable vector types from ARM SVE or RISC-V? I can't remember what the rest of the __builtin_elementwise do. I ask because the backends will probably crash for them.

I sat with @beanz and looked at the assembly code generated for the riscv64-unknown-elf target and the aarch64-apple-darwin target, with and without the sve target feature.
The compiler doesn't crash. The generated assembly looks good, there are 4 sinf calls, one generated for each element in the vector.

[bob80905]

Here is the code I used to test the machine code output:

typedef float float4 __attribute__((ext_vector_type(4)));

void test_builtin_elementwise_sin(float f1, float f2, double d1, double d2, 
float4 vf1, float4 vf2)
{
  f2 = __builtin_elementwise_sin(f1);
  d2 = __builtin_elementwise_sin(d1);
  vf2 = __builtin_elementwise_sin(vf1);
}

f2 = builtin_elementwise_sin(f1); can be swapped for f2 = builtin_elementwise_cos(f1); to test the cos builtin,

[python3kgae]

In D135011#3834739, @bob80905 wrote:

Here is the code I used to test the machine code output:

typedef float float4 __attribute__((ext_vector_type(4)));

void test_builtin_elementwise_sin(float f1, float f2, double d1, double d2, 
float4 vf1, float4 vf2)
{
  f2 = __builtin_elementwise_sin(f1);
  d2 = __builtin_elementwise_sin(d1);
  vf2 = __builtin_elementwise_sin(vf1);
}

f2 = builtin_elementwise_sin(f1); can be swapped for f2 = builtin_elementwise_cos(f1); to test the cos builtin,

Not sure these will test scalable vector types.
Maybe something like vfloat32mf2_t or svfloat32_t?

[bob80905]

• add sve tests to prove compiler doesn't crash

[bob80905]

• add new line to end of new files

[craig.topper]

In D135011#3835553, @bob80905 wrote:

• add sve tests to prove compiler doesn't crash

Thank you.

clang/docs/LanguageExtensions.rst

607

hypotenuse*

[craig.topper]

clang/docs/LanguageExtensions.rst

606

This list doesn't appear to be in an overall alphabetical order. It looks more like its grouped by similarity. add_sat/sub_sat are together for example.

[scanon]

clang/docs/LanguageExtensions.rst

607

As long as we're tweaking descriptions, please just call these "cosine" and "sine" instead of a cumbersome ratio description. "The cosine of x interpreted as an angle in radians" or similar.

[bob80905]

• shorten builtin description, group sin and cos

[bob80905]

Ping

[craig.topper]

clang/docs/ReleaseNotes.rst

473 ↗

(On Diff #465446)

Drop "llvm" from this sentence.

[bob80905]

• drop llvm from release notes description.

[bob80905]

Ping, could someone please take a look?

[bob80905]

Ping

[bob80905]

Ping

[bob80905]

Ping

[craig.topper]

LGTM to me with those formatting fixes.

clang/test/CodeGen/builtins-elementwise-math.c

337

Line these up with the start of the arguments on the previous line.

385

Same

[bob80905]

• make format change

[python3kgae]

clang/test/Sema/aarch64-sve-vector-trig-ops.c

4 ↗

(On Diff #474570)

Need limit to aarch64 enabled with
// REQUIRES: aarch64-registered-target

clang/test/Sema/riscv-sve-vector-trig-ops.c

4 ↗

(On Diff #474570)

// REQUIRES: riscv-registered-target

[fhahn]

LGTM with the suggested changes, thanks!

[bob80905]

• add dependency on architecture before testing

clang/docs/LanguageExtensions.rst

 Unless specified otherwise operation(±0) = ±0 and operation(±infinity) = ±infinity
 
 =========================================== ================================================================ =========================================
          Name                                Operation                                                        Supported element types
 =========================================== ================================================================ =========================================
  T __builtin_elementwise_abs(T x)            return the absolute value of a number x; the absolute value of   signed integer and floating point types
                                              the most negative integer remains the most negative integer
  T __builtin_elementwise_ceil(T x)           return the smallest integral value greater than or equal to x    floating point types
+ T __builtin_elementwise_cos(T x)            return the ratio of the adjacent side length over the            floating point types
+                                             hypoteneuse side length, given the angle x in radians            
  T __builtin_elementwise_floor(T x)          return the largest integral value less than or equal to x        floating point types
  T __builtin_elementwise_roundeven(T x)      round x to the nearest integer value in floating point format,   floating point types
                                              rounding halfway cases to even (that is, to the nearest value
                                              that is an even integer), regardless of the current rounding
                                              direction.
+ T __builtin_elementwise_sin(T x)            return the ratio of the opposite side length over the            floating point types
+                                             hypoteneuse side length, given the angle x in radians 
  T__builtin_elementwise_trunc(T x)           return the integral value nearest to but no larger in            floating point types
                                              magnitude than x
  T __builtin_elementwise_max(T x, T y)       return x or y, whichever is larger                               integer and floating point types
  T __builtin_elementwise_min(T x, T y)       return x or y, whichever is smaller                              integer and floating point types
  T __builtin_elementwise_add_sat(T x, T y)   return the sum of x and y, clamped to the range of               integer types
                                              representable values for the signed/unsigned integer type.
  T __builtin_elementwise_sub_sat(T x, T y)   return the difference of x and y, clamped to the range of        integer types
                                              representable values for the signed/unsigned integer type.

clang/include/clang/Basic/Builtins.def

 BUILTIN(__builtin_alloca_with_align, "v*zIz", "Fn")
 BUILTIN(__builtin_alloca_with_align_uninitialized, "v*zIz", "Fn")
 BUILTIN(__builtin_call_with_static_chain, "v.", "nt")
 
 BUILTIN(__builtin_elementwise_abs, "v.", "nct")
 BUILTIN(__builtin_elementwise_max, "v.", "nct")
 BUILTIN(__builtin_elementwise_min, "v.", "nct")
 BUILTIN(__builtin_elementwise_ceil, "v.", "nct")
+BUILTIN(__builtin_elementwise_cos, "v.", "nct")
 BUILTIN(__builtin_elementwise_floor, "v.", "nct")
 BUILTIN(__builtin_elementwise_roundeven, "v.", "nct")
+BUILTIN(__builtin_elementwise_sin, "v.", "nct")
 BUILTIN(__builtin_elementwise_trunc, "v.", "nct")
 BUILTIN(__builtin_elementwise_add_sat, "v.", "nct")
 BUILTIN(__builtin_elementwise_sub_sat, "v.", "nct")
 BUILTIN(__builtin_reduce_max, "v.", "nct")
 BUILTIN(__builtin_reduce_min, "v.", "nct")
 BUILTIN(__builtin_reduce_xor, "v.", "nct")
 BUILTIN(__builtin_reduce_or, "v.", "nct")
 BUILTIN(__builtin_reduce_and, "v.", "nct")

clang/lib/CodeGen/CGBuiltin.cpp

else
       Result = emitUnaryBuiltin(*this, E, llvm::Intrinsic::fabs, "elt.abs");
 
     return RValue::get(Result);
   }
 
   case Builtin::BI__builtin_elementwise_ceil:
     return RValue::get(
         emitUnaryBuiltin(*this, E, llvm::Intrinsic::ceil, "elt.ceil"));
+  case Builtin::BI__builtin_elementwise_cos:
+    return RValue::get(
+        emitUnaryBuiltin(*this, E, llvm::Intrinsic::cos, "elt.cos"));
   case Builtin::BI__builtin_elementwise_floor:
     return RValue::get(
         emitUnaryBuiltin(*this, E, llvm::Intrinsic::floor, "elt.floor"));
   case Builtin::BI__builtin_elementwise_roundeven:
     return RValue::get(emitUnaryBuiltin(*this, E, llvm::Intrinsic::roundeven,
                                         "elt.roundeven"));
+  case Builtin::BI__builtin_elementwise_sin:
+    return RValue::get(
+        emitUnaryBuiltin(*this, E, llvm::Intrinsic::sin, "elt.sin"));
+
   case Builtin::BI__builtin_elementwise_trunc:
     return RValue::get(
         emitUnaryBuiltin(*this, E, llvm::Intrinsic::trunc, "elt.trunc"));
 
   case Builtin::BI__builtin_elementwise_add_sat:
   case Builtin::BI__builtin_elementwise_sub_sat: {
     Value *Op0 = EmitScalarExpr(E->getArg(0));
     Value *Op1 = EmitScalarExpr(E->getArg(1));

clang/lib/Sema/SemaChecking.cpp

if (EltTy->isUnsignedIntegerType()) {
       return ExprError();
     }
     break;
   }
 
   // These builtins restrict the element type to floating point
   // types only.
   case Builtin::BI__builtin_elementwise_ceil:
+  case Builtin::BI__builtin_elementwise_cos:
   case Builtin::BI__builtin_elementwise_floor:
   case Builtin::BI__builtin_elementwise_roundeven:
+  case Builtin::BI__builtin_elementwise_sin:
   case Builtin::BI__builtin_elementwise_trunc: {
     if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
       return ExprError();
 
     QualType ArgTy = TheCall->getArg(0)->getType();
     QualType EltTy = ArgTy;
 
     if (auto *VecTy = EltTy->getAs<VectorType>())

clang/test/CodeGen/builtins-elementwise-math.c

void test_builtin_elementwise_ceil(float f1, float f2, double d1, double d2,
   // CHECK-NEXT: call double @llvm.ceil.f64(double [[D1]])
   d2 = __builtin_elementwise_ceil(d1);
 
   // CHECK:      [[VF1:%.+]] = load <4 x float>, <4 x float>* %vf1.addr, align 16
   // CHECK-NEXT: call <4 x float> @llvm.ceil.v4f32(<4 x float> [[VF1]])
   vf2 = __builtin_elementwise_ceil(vf1);
 }
 
+void test_builtin_elementwise_cos(float f1, float f2, double d1, double d2,
+  float4 vf1, float4 vf2) {
+  // CHECK-LABEL: define void @test_builtin_elementwise_cos(
+  // CHECK:      [[F1:%.+]] = load float, float* %f1.addr, align 4
+  // CHECK-NEXT:  call float @llvm.cos.f32(float [[F1]])
+  f2 = __builtin_elementwise_cos(f1);
+
+  // CHECK:      [[D1:%.+]] = load double, double* %d1.addr, align 8
+  // CHECK-NEXT: call double @llvm.cos.f64(double [[D1]])
+  d2 = __builtin_elementwise_cos(d1);
+
+  // CHECK:      [[VF1:%.+]] = load <4 x float>, <4 x float>* %vf1.addr, align 16
+  // CHECK-NEXT: call <4 x float> @llvm.cos.v4f32(<4 x float> [[VF1]])
+  vf2 = __builtin_elementwise_cos(vf1);
+}
+
 void test_builtin_elementwise_floor(float f1, float f2, double d1, double d2,
                                     float4 vf1, float4 vf2) {
   // CHECK-LABEL: define void @test_builtin_elementwise_floor(
   // CHECK:      [[F1:%.+]] = load float, float* %f1.addr, align 4
   // CHECK-NEXT:  call float @llvm.floor.f32(float [[F1]])
   f2 = __builtin_elementwise_floor(f1);
 
   // CHECK:      [[D1:%.+]] = load double, double* %d1.addr, align 8
void test_builtin_elementwise_roundeven(float f1, float f2, double d1, double d2,
   // CHECK-NEXT: call double @llvm.roundeven.f64(double [[D1]])
   d2 = __builtin_elementwise_roundeven(d1);
 
   // CHECK:      [[VF1:%.+]] = load <4 x float>, <4 x float>* %vf1.addr, align 16
   // CHECK-NEXT: call <4 x float> @llvm.roundeven.v4f32(<4 x float> [[VF1]])
   vf2 = __builtin_elementwise_roundeven(vf1);
 }
 
+void test_builtin_elementwise_sin(float f1, float f2, double d1, double d2,
+  float4 vf1, float4 vf2) {
+  // CHECK-LABEL: define void @test_builtin_elementwise_sin(
+  // CHECK:      [[F1:%.+]] = load float, float* %f1.addr, align 4
+  // CHECK-NEXT:  call float @llvm.sin.f32(float [[F1]])
+  f2 = __builtin_elementwise_sin(f1);
+
+  // CHECK:      [[D1:%.+]] = load double, double* %d1.addr, align 8
+  // CHECK-NEXT: call double @llvm.sin.f64(double [[D1]])
+  d2 = __builtin_elementwise_sin(d1);
+
+  // CHECK:      [[VF1:%.+]] = load <4 x float>, <4 x float>* %vf1.addr, align 16
+  // CHECK-NEXT: call <4 x float> @llvm.sin.v4f32(<4 x float> [[VF1]])
+  vf2 = __builtin_elementwise_sin(vf1);
+}
+
 void test_builtin_elementwise_trunc(float f1, float f2, double d1, double d2,
                                     float4 vf1, float4 vf2) {
   // CHECK-LABEL: define void @test_builtin_elementwise_trunc(
   // CHECK:      [[F1:%.+]] = load float, float* %f1.addr, align 4
   // CHECK-NEXT:  call float @llvm.trunc.f32(float [[F1]])
   f2 = __builtin_elementwise_trunc(f1);
 
   // CHECK:      [[D1:%.+]] = load double, double* %d1.addr, align 8
   // CHECK-NEXT: call double @llvm.trunc.f64(double [[D1]])
   d2 = __builtin_elementwise_trunc(d1);
 
   // CHECK:      [[VF1:%.+]] = load <4 x float>, <4 x float>* %vf1.addr, align 16
   // CHECK-NEXT: call <4 x float> @llvm.trunc.v4f32(<4 x float> [[VF1]])
   vf2 = __builtin_elementwise_trunc(vf1);
 }

clang/test/Sema/builtins-elementwise-math.c

void test_builtin_elementwise_ceil(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 
   u = __builtin_elementwise_ceil(u);
   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 
   uv = __builtin_elementwise_ceil(uv);
   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 }
 
+void test_builtin_elementwise_cos(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
+
+  struct Foo s = __builtin_elementwise_cos(f);
+  // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
+
+  i = __builtin_elementwise_cos();
+  // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
+
+  i = __builtin_elementwise_cos(i);
+  // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
+
+  i = __builtin_elementwise_cos(f, f);
+  // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
+
+  u = __builtin_elementwise_cos(u);
+  // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
+
+  uv = __builtin_elementwise_cos(uv);
+  // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
+}
+
 void test_builtin_elementwise_floor(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 
   struct Foo s = __builtin_elementwise_floor(f);
   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 
   i = __builtin_elementwise_floor();
   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 
void test_builtin_elementwise_roundeven(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 
   u = __builtin_elementwise_roundeven(u);
   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 
   uv = __builtin_elementwise_roundeven(uv);
   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 }
 
+void test_builtin_elementwise_sin(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
+
+  struct Foo s = __builtin_elementwise_sin(f);
+  // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
+
+  i = __builtin_elementwise_sin();
+  // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
+
+  i = __builtin_elementwise_sin(i);
+  // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
+
+  i = __builtin_elementwise_sin(f, f);
+  // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
+
+  u = __builtin_elementwise_sin(u);
+  // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
+
+  uv = __builtin_elementwise_sin(uv);
+  // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
+}
+
 void test_builtin_elementwise_trunc(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 
   struct Foo s = __builtin_elementwise_trunc(f);
   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 
   i = __builtin_elementwise_trunc();
   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 

clang/test/SemaCXX/builtins-elementwise-math.cpp

 }
 
 void test_builtin_elementwise_ceil() {
   const float a = 42.0;
   float b = 42.3;
   static_assert(!is_const<decltype(__builtin_elementwise_ceil(a))>::value);
   static_assert(!is_const<decltype(__builtin_elementwise_ceil(b))>::value);
 }
+
+void test_builtin_elementwise_cos() {
+  const float a = 42.0;
+  float b = 42.3;
+  static_assert(!is_const<decltype(__builtin_elementwise_cos(a))>::value);
+  static_assert(!is_const<decltype(__builtin_elementwise_cos(b))>::value);
+}
+
+void test_builtin_elementwise_sin() {
+  const float a = 42.0;
+  float b = 42.3;
+  static_assert(!is_const<decltype(__builtin_elementwise_sin(a))>::value);
+  static_assert(!is_const<decltype(__builtin_elementwise_sin(b))>::value);
+}