Skip to content

[IR] Add a test for f128 libm libcall lowering (NFC) #148308

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Jul 14, 2025
Merged
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
337 changes: 337 additions & 0 deletions llvm/test/CodeGen/Generic/fp128-math-libcalls.ll
Original file line number Diff line number Diff line change
@@ -0,0 +1,337 @@
; Verify that fp128 intrinsics only lower to `long double` calls (e.g. sinl) on
; platforms where 128 and `long double` have the same layout. Otherwise, lower
; to f128 versions (e.g. sinf128).
;
; Targets include:
; * aarch64 (long double == f128, should use ld syms)
; * arm (long double == f64, should use f128 syms)
; * s390x (long double == f128, should use ld syms, some hardware support)
; * x86, x64 (80-bit long double, should use ld syms)
; * gnu (has f128 symbols on all platforms so we can use those)
; * musl (no f128 symbols available)
; * Windows and MacOS (no f128 symbols, long double == f64)

; FIXME(#44744): arm32, x86-{32,64} musl targets, MacOS, and Windows don't have
; f128 long double. They should be passing with CHECK-F128 rather than
; CHECK-USELD.

; RUN: %if aarch64-registered-target %{ llc < %s -mtriple=aarch64-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
; RUN: %if aarch64-registered-target %{ llc < %s -mtriple=aarch64-unknown-linux-musl | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
; RUN: %if aarch64-registered-target %{ llc < %s -mtriple=aarch64-unknown-none | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
; RUN: %if aarch64-registered-target %{ llc < %s -mtriple=arm64-apple-macosx | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
; RUN: %if arm-registered-target %{ llc < %s -mtriple=arm-none-eabi | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
; RUN: %if arm-registered-target %{ llc < %s -mtriple=arm-unknown-linux-gnueabi | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
; RUN: %if powerpc-registered-target %{ llc < %s -mtriple=powerpc-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}
; RUN: %if powerpc-registered-target %{ llc < %s -mtriple=powerpc64-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}
; RUN: %if powerpc-registered-target %{ llc < %s -mtriple=powerpc64-unknown-linux-musl | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}
; RUN: %if riscv-registered-target %{ llc < %s -mtriple=riscv32-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
; RUN: %if systemz-registered-target %{ llc < %s -mtriple=s390x-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-S390X %}
; RUN: %if x86-registered-target %{ llc < %s -mtriple=i686-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}
; RUN: %if x86-registered-target %{ llc < %s -mtriple=i686-unknown-linux-musl | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
; RUN: %if x86-registered-target %{ llc < %s -mtriple=x86_64-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}
; RUN: %if x86-registered-target %{ llc < %s -mtriple=x86_64-unknown-linux-musl | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
;
; FIXME(#144006): Windows-MSVC should also be run but has a ldexp selection
; failure.
; %if x86-registered-target %{ llc < %s -mtriple=x86_64-pc-windows-msvc -verify-machineinstrs | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}

define fp128 @test_acos(fp128 %a) {
; CHECK-ALL-LABEL: test_acos:
; CHECK-F128: acosf128
; CHECK-USELD: acosl
; CHECK-S390X: acosl
start:
%0 = tail call fp128 @llvm.acos.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_asin(fp128 %a) {
; CHECK-ALL-LABEL: test_asin:
; CHECK-F128: asinf128
; CHECK-USELD: asinl
; CHECK-S390X: asinl
start:
%0 = tail call fp128 @llvm.asin.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_atan(fp128 %a) {
; CHECK-ALL-LABEL: test_atan:
; CHECK-F128: atanf128
; CHECK-USELD: atanl
; CHECK-S390X: atanl
start:
%0 = tail call fp128 @llvm.atan.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_ceil(fp128 %a) {
; CHECK-ALL-LABEL: test_ceil:
; CHECK-F128: ceilf128
; CHECK-USELD: ceill
; CHECK-S390X: ceill
start:
%0 = tail call fp128 @llvm.ceil.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_copysign(fp128 %a, fp128 %b) {
; copysign should always get lowered to assembly.
; CHECK-ALL-LABEL: test_copysign:
; CHECK-ALL-NOT: copysignf128
; CHECK-ALL-NOT: copysignl
start:
%0 = tail call fp128 @llvm.copysign.f128(fp128 %a, fp128 %b)
ret fp128 %0
}

define fp128 @test_cos(fp128 %a) {
; CHECK-ALL-LABEL: test_cos:
; CHECK-F128: cosf128
; CHECK-USELD: cosl
; CHECK-S390X: cosl
start:
%0 = tail call fp128 @llvm.cos.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_exp10(fp128 %a) {
; CHECK-ALL-LABEL: test_exp10:
; CHECK-F128: exp10f128
; CHECK-USELD: exp10l
; CHECK-S390X: exp10l
start:
%0 = tail call fp128 @llvm.exp10.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_exp2(fp128 %a) {
; CHECK-ALL-LABEL: test_exp2:
; CHECK-F128: exp2f128
; CHECK-USELD: exp2l
; CHECK-S390X: exp2l
start:
%0 = tail call fp128 @llvm.exp2.f128(fp128 %a)
ret fp128 %0
}


define fp128 @test_exp(fp128 %a) {
; CHECK-ALL-LABEL: test_exp:
; CHECK-F128: expf128
; CHECK-USELD: expl
; CHECK-S390X: expl
start:
%0 = tail call fp128 @llvm.exp.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_fabs(fp128 %a) {
; fabs should always get lowered to assembly.
; CHECK-ALL-LABEL: test_fabs:
; CHECK-ALL-NOT: fabsf128
; CHECK-ALL-NOT: fabsl
start:
%0 = tail call fp128 @llvm.fabs.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_floor(fp128 %a) {
; CHECK-ALL-LABEL: test_floor:
; CHECK-F128: floorf128
; CHECK-USELD: floorl
; CHECK-S390X: floorl
start:
%0 = tail call fp128 @llvm.floor.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_fma(fp128 %a, fp128 %b, fp128 %c) {
; CHECK-ALL-LABEL: test_fma:
; CHECK-F128: fmaf128
; CHECK-USELD: fmal
; CHECK-S390X: fmal
start:
%0 = tail call fp128 @llvm.fma.f128(fp128 %a, fp128 %b, fp128 %c)
ret fp128 %0
}

define { fp128, i32 } @test_frexp(fp128 %a) {
; CHECK-ALL-LABEL: test_frexp:
; CHECK-F128: frexpf128
; CHECK-USELD: frexpl
; CHECK-S390X: frexpl
start:
%0 = tail call { fp128, i32 } @llvm.frexp.f128(fp128 %a)
ret { fp128, i32 } %0
}

define fp128 @test_ldexp(fp128 %a, i32 %b) {
; CHECK-ALL-LABEL: test_ldexp:
; CHECK-F128: ldexpf128
; CHECK-USELD: ldexpl
; CHECK-S390X: ldexpl
start:
%0 = tail call fp128 @llvm.ldexp.f128(fp128 %a, i32 %b)
ret fp128 %0
}

define i64 @test_llrint(fp128 %a) {
; CHECK-ALL-LABEL: test_llrint:
; CHECK-F128: llrintf128
; CHECK-USELD: llrintl
; CHECK-S390X: llrintl
start:
%0 = tail call i64 @llvm.llrint.f128(fp128 %a)
ret i64 %0
}

define i64 @test_llround(fp128 %a) {
; CHECK-ALL-LABEL: test_llround:
; CHECK-F128: llroundf128
; CHECK-USELD: llroundl
; CHECK-S390X: llroundl
start:
%0 = tail call i64 @llvm.llround.i64.f128(fp128 %a)
ret i64 %0
}

define fp128 @test_log10(fp128 %a) {
; CHECK-ALL-LABEL: test_log10:
; CHECK-F128: log10f128
; CHECK-USELD: log10l
; CHECK-S390X: log10l
start:
%0 = tail call fp128 @llvm.log10.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_log2(fp128 %a) {
; CHECK-ALL-LABEL: test_log2:
; CHECK-F128: log2f128
; CHECK-USELD: log2l
; CHECK-S390X: log2l
start:
%0 = tail call fp128 @llvm.log2.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_log(fp128 %a) {
; CHECK-ALL-LABEL: test_log:
; CHECK-F128: logf128
; CHECK-USELD: logl
; CHECK-S390X: logl
start:
%0 = tail call fp128 @llvm.log.f128(fp128 %a)
ret fp128 %0
}

define i64 @test_lrint(fp128 %a) {
; CHECK-ALL-LABEL: test_lrint:
; CHECK-F128: lrintf128
; CHECK-USELD: lrintl
; CHECK-S390X: lrintl
start:
%0 = tail call i64 @llvm.lrint.f128(fp128 %a)
ret i64 %0
}

define i64 @test_lround(fp128 %a) {
; CHECK-ALL-LABEL: test_lround:
; CHECK-F128: lroundf128
; CHECK-USELD: lroundl
; CHECK-S390X: lroundl
start:
%0 = tail call i64 @llvm.lround.i64.f128(fp128 %a)
ret i64 %0
}

define fp128 @test_nearbyint(fp128 %a) {
; CHECK-ALL-LABEL: test_nearbyint:
; CHECK-F128: nearbyintf128
; CHECK-USELD: nearbyintl
; CHECK-S390X: nearbyintl
start:
%0 = tail call fp128 @llvm.nearbyint.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_pow(fp128 %a, fp128 %b) {
; CHECK-ALL-LABEL: test_pow:
; CHECK-F128: powf128
; CHECK-USELD: powl
; CHECK-S390X: powl
start:
%0 = tail call fp128 @llvm.pow.f128(fp128 %a, fp128 %b)
ret fp128 %0
}

define fp128 @test_rint(fp128 %a) {
; CHECK-ALL-LABEL: test_rint:
; CHECK-F128: rintf128
; CHECK-USELD: rintl
; CHECK-S390X: fixbr {{%.*}}, 0, {{%.*}}
start:
%0 = tail call fp128 @llvm.rint.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_roundeven(fp128 %a) {
; CHECK-ALL-LABEL: test_roundeven:
; CHECK-F128: roundevenf128
; CHECK-USELD: roundevenl
; CHECK-S390X: roundevenl
start:
%0 = tail call fp128 @llvm.roundeven.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_round(fp128 %a) {
; CHECK-ALL-LABEL: test_round:
; CHECK-F128: roundf128
; CHECK-USELD: roundl
; CHECK-S390X: roundl
start:
%0 = tail call fp128 @llvm.round.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_sin(fp128 %a) {
; CHECK-ALL-LABEL: test_sin:
; CHECK-F128: sinf128
; CHECK-USELD: sinl
; CHECK-S390X: sinl
start:
%0 = tail call fp128 @llvm.sin.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_sqrt(fp128 %a) {
; CHECK-ALL-LABEL: test_sqrt:
; CHECK-F128: sqrtf128
; CHECK-USELD: sqrtl
; CHECK-S390X: sqxbr {{%.*}}, {{%.*}}
start:
%0 = tail call fp128 @llvm.sqrt.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_tan(fp128 %a) {
; CHECK-ALL-LABEL: test_tan:
; CHECK-F128: tanf128
; CHECK-USELD: tanl
; CHECK-S390X: tanl
start:
%0 = tail call fp128 @llvm.tan.f128(fp128 %a)
ret fp128 %0
}

define fp128 @test_trunc(fp128 %a) {
; CHECK-ALL-LABEL: test_trunc:
; CHECK-F128: truncf128
; CHECK-USELD: truncl
; CHECK-S390X: truncl
start:
%0 = tail call fp128 @llvm.trunc.f128(fp128 %a)
ret fp128 %0
}
Loading