Skip to content

Commit c08b0a8

Browse files
wzssyqawzssyqa
committed
Clang: Support minimumnum and maximumnum intrinsics
We just introduce llvm.minimumnum and llvm.maximumnum intrinsics support to llvm. Let's support them in Clang. See: #93033
1 parent bf81bd8 commit c08b0a8

File tree

6 files changed

+119
-0
lines changed

6 files changed

+119
-0
lines changed

‎clang/include/clang/Basic/Builtins.td

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -215,6 +215,18 @@ def FminF16F128 : Builtin, F16F128MathTemplate {
215215
let Prototype = "T(T, T)";
216216
}
217217

218+
def FmaximumNumF16F128 : Builtin, F16F128MathTemplate {
219+
let Spellings = ["__builtin_fmaximum_num"];
220+
let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const, Constexpr];
221+
let Prototype = "T(T, T)";
222+
}
223+
224+
def FminimumNumF16F128 : Builtin, F16F128MathTemplate {
225+
let Spellings = ["__builtin_fminimum_num"];
226+
let Attributes = [FunctionWithBuiltinPrefix, NoThrow, Const, Constexpr];
227+
let Prototype = "T(T, T)";
228+
}
229+
218230
def Atan2F128 : Builtin {
219231
let Spellings = ["__builtin_atan2f128"];
220232
let Attributes = [FunctionWithBuiltinPrefix, NoThrow, ConstIgnoringErrnoAndExceptions];
@@ -3728,6 +3740,22 @@ def Fmin : FPMathTemplate, LibBuiltin<"math.h"> {
37283740
let OnlyBuiltinPrefixedAliasIsConstexpr = 1;
37293741
}
37303742

3743+
def FmaximumNum : FPMathTemplate, LibBuiltin<"math.h"> {
3744+
let Spellings = ["fmaximum_num"];
3745+
let Attributes = [NoThrow, Const];
3746+
let Prototype = "T(T, T)";
3747+
let AddBuiltinPrefixedAlias = 1;
3748+
let OnlyBuiltinPrefixedAliasIsConstexpr = 1;
3749+
}
3750+
3751+
def FminimumNum : FPMathTemplate, LibBuiltin<"math.h"> {
3752+
let Spellings = ["fminimum_num"];
3753+
let Attributes = [NoThrow, Const];
3754+
let Prototype = "T(T, T)";
3755+
let AddBuiltinPrefixedAlias = 1;
3756+
let OnlyBuiltinPrefixedAliasIsConstexpr = 1;
3757+
}
3758+
37313759
def Hypot : FPMathTemplate, LibBuiltin<"math.h"> {
37323760
let Spellings = ["hypot"];
37333761
let Attributes = [NoThrow, ConstIgnoringErrnoAndExceptions];

‎clang/lib/CodeGen/CGBuiltin.cpp

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2869,6 +2869,30 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
28692869
Intrinsic::minnum,
28702870
Intrinsic::experimental_constrained_minnum));
28712871

2872+
case Builtin::BIfmaximum_num:
2873+
case Builtin::BIfmaximum_numf:
2874+
case Builtin::BIfmaximum_numl:
2875+
case Builtin::BI__builtin_fmaximum_num:
2876+
case Builtin::BI__builtin_fmaximum_numf:
2877+
case Builtin::BI__builtin_fmaximum_numf16:
2878+
case Builtin::BI__builtin_fmaximum_numl:
2879+
case Builtin::BI__builtin_fmaximum_numf128:
2880+
return RValue::get(emitBinaryMaybeConstrainedFPBuiltin(
2881+
*this, E, Intrinsic::maximumnum,
2882+
Intrinsic::experimental_constrained_maximumnum));
2883+
2884+
case Builtin::BIfminimum_num:
2885+
case Builtin::BIfminimum_numf:
2886+
case Builtin::BIfminimum_numl:
2887+
case Builtin::BI__builtin_fminimum_num:
2888+
case Builtin::BI__builtin_fminimum_numf:
2889+
case Builtin::BI__builtin_fminimum_numf16:
2890+
case Builtin::BI__builtin_fminimum_numl:
2891+
case Builtin::BI__builtin_fminimum_numf128:
2892+
return RValue::get(emitBinaryMaybeConstrainedFPBuiltin(
2893+
*this, E, Intrinsic::minimumnum,
2894+
Intrinsic::experimental_constrained_minimumnum));
2895+
28722896
// fmod() is a special-case. It maps to the frem instruction rather than an
28732897
// LLVM intrinsic.
28742898
case Builtin::BIfmod:

‎clang/lib/Tooling/Inclusions/Stdlib/CSymbolMap.inc

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -475,6 +475,12 @@ SYMBOL(fmaxl, None, <math.h>)
475475
SYMBOL(fmin, None, <math.h>)
476476
SYMBOL(fminf, None, <math.h>)
477477
SYMBOL(fminl, None, <math.h>)
478+
SYMBOL(fmaximum_num, None, <math.h>)
479+
SYMBOL(fmaximum_numf, None, <math.h>)
480+
SYMBOL(fmaximum_numfl, None, <math.h>)
481+
SYMBOL(fminimum_num, None, <math.h>)
482+
SYMBOL(fminimum_numf, None, <math.h>)
483+
SYMBOL(fminimum_numl, None, <math.h>)
478484
SYMBOL(fmod, None, <math.h>)
479485
SYMBOL(fmodf, None, <math.h>)
480486
SYMBOL(fmodl, None, <math.h>)

‎clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1295,6 +1295,24 @@ SYMBOL(fminf, None, <math.h>)
12951295
SYMBOL(fminl, std::, <cmath>)
12961296
SYMBOL(fminl, None, <cmath>)
12971297
SYMBOL(fminl, None, <math.h>)
1298+
SYMBOL(fmaximum_num, std::, <cmath>)
1299+
SYMBOL(fmaximum_num, None, <cmath>)
1300+
SYMBOL(fmaximum_num, None, <math.h>)
1301+
SYMBOL(fmaximum_numf, std::, <cmath>)
1302+
SYMBOL(fmaximum_numf, None, <cmath>)
1303+
SYMBOL(fmaximum_numf, None, <math.h>)
1304+
SYMBOL(fmaximum_numl, std::, <cmath>)
1305+
SYMBOL(fmaximum_numl, None, <cmath>)
1306+
SYMBOL(fmaximum_numl, None, <math.h>)
1307+
SYMBOL(fminimum_num, std::, <cmath>)
1308+
SYMBOL(fminimum_num, None, <cmath>)
1309+
SYMBOL(fminimum_num, None, <math.h>)
1310+
SYMBOL(fminimum_numf, std::, <cmath>)
1311+
SYMBOL(fminimum_numf, None, <cmath>)
1312+
SYMBOL(fminimum_numf, None, <math.h>)
1313+
SYMBOL(fminimum_numl, std::, <cmath>)
1314+
SYMBOL(fminimum_numl, None, <cmath>)
1315+
SYMBOL(fminimum_numl, None, <math.h>)
12981316
SYMBOL(fmod, std::, <cmath>)
12991317
SYMBOL(fmod, None, <cmath>)
13001318
SYMBOL(fmod, None, <math.h>)

‎clang/test/CodeGen/builtins.c

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -353,6 +353,24 @@ void test_float_builtin_ops(float F, double D, long double LD) {
353353
resld = __builtin_fmaxl(LD, LD);
354354
// CHECK: call x86_fp80 @llvm.maxnum.f80
355355

356+
resf = __builtin_fminimum_numf(F, F);
357+
// CHECK: call float @llvm.minimumnum.f32
358+
359+
resd = __builtin_fminimum_num(D, D);
360+
// CHECK: call double @llvm.minimumnum.f64
361+
362+
resld = __builtin_fminimum_numl(LD, LD);
363+
// CHECK: call x86_fp80 @llvm.minimumnum.f80
364+
365+
resf = __builtin_fmaximum_numf(F, F);
366+
// CHECK: call float @llvm.maximumnum.f32
367+
368+
resd = __builtin_fmaximum_num(D, D);
369+
// CHECK: call double @llvm.maximumnum.f64
370+
371+
resld = __builtin_fmaximum_numl(LD, LD);
372+
// CHECK: call x86_fp80 @llvm.maximumnum.f80
373+
356374
resf = __builtin_fabsf(F);
357375
// CHECK: call float @llvm.fabs.f32
358376

‎clang/test/CodeGen/math-libcalls.c

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -372,6 +372,31 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) {
372372
// HAS_MAYTRAP: declare float @llvm.experimental.constrained.minnum.f32(
373373
// HAS_MAYTRAP: declare x86_fp80 @llvm.experimental.constrained.minnum.f80(
374374

375+
fmaximum_num(f,f); fmaximum_numf(f,f); fmaximum_numl(f,f);
376+
377+
// NO__ERRNO: declare double @llvm.maximumnum.f64(double, double) [[READNONE_INTRINSIC]]
378+
// NO__ERRNO: declare float @llvm.maximumnum.f32(float, float) [[READNONE_INTRINSIC]]
379+
// NO__ERRNO: declare x86_fp80 @llvm.maximumnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
380+
// HAS_ERRNO: declare double @llvm.maximumnum.f64(double, double) [[READNONE_INTRINSIC]]
381+
// HAS_ERRNO: declare float @llvm.maximumnum.f32(float, float) [[READNONE_INTRINSIC]]
382+
// HAS_ERRNO: declare x86_fp80 @llvm.maximumnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
383+
// HAS_MAYTRAP: declare double @llvm.experimental.constrained.maximumnum.f64(
384+
// HAS_MAYTRAP: declare float @llvm.experimental.constrained.maximumnum.f32(
385+
// HAS_MAYTRAP: declare x86_fp80 @llvm.experimental.constrained.maximumnum.f80(
386+
387+
fminimum_num(f,f); fminimum_numf(f,f); fminimum_numl(f,f);
388+
389+
// NO__ERRNO: declare double @llvm.minimumnum.f64(double, double) [[READNONE_INTRINSIC]]
390+
// NO__ERRNO: declare float @llvm.minimumnum.f32(float, float) [[READNONE_INTRINSIC]]
391+
// NO__ERRNO: declare x86_fp80 @llvm.minimumnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
392+
// HAS_ERRNO: declare double @llvm.minimumnum.f64(double, double) [[READNONE_INTRINSIC]]
393+
// HAS_ERRNO: declare float @llvm.minimumnum.f32(float, float) [[READNONE_INTRINSIC]]
394+
// HAS_ERRNO: declare x86_fp80 @llvm.minimumnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
395+
// HAS_MAYTRAP: declare double @llvm.experimental.constrained.minimumnum.f64(
396+
// HAS_MAYTRAP: declare float @llvm.experimental.constrained.minimumnum.f32(
397+
// HAS_MAYTRAP: declare x86_fp80 @llvm.experimental.constrained.minimumnum.f80(
398+
399+
375400
hypot(f,f); hypotf(f,f); hypotl(f,f);
376401

377402
// NO__ERRNO: declare double @hypot(double noundef, double noundef) [[READNONE]]

0 commit comments

Comments
 (0)