From 05221b43feadc023ee7d464bd908c0bbff82d203 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Thu, 7 Aug 2025 15:53:53 +0200 Subject: [PATCH 1/2] [X86][Inline] Check correct function for target feature check The check for ABI differences for inlined calls involves the caller, the callee and the nested callee. Before inlining, the ABI is determined by the target features of the callee. After inlining it is determined by the caller. The features of the nested callee should never actually matter. --- .../lib/Target/X86/X86TargetTransformInfo.cpp | 18 ++------- .../Inline/X86/call-abi-compatibility.ll | 38 ++++++++++++++++--- 2 files changed, 36 insertions(+), 20 deletions(-) diff --git a/llvm/lib/Target/X86/X86TargetTransformInfo.cpp b/llvm/lib/Target/X86/X86TargetTransformInfo.cpp index 90791fc5788f4..fdae0ba7c483b 100644 --- a/llvm/lib/Target/X86/X86TargetTransformInfo.cpp +++ b/llvm/lib/Target/X86/X86TargetTransformInfo.cpp @@ -6525,8 +6525,8 @@ bool X86TTIImpl::areInlineCompatible(const Function *Caller, for (const Instruction &I : instructions(Callee)) { if (const auto *CB = dyn_cast(&I)) { - // Having more target features is fine for inline ASM. - if (CB->isInlineAsm()) + // Having more target features is fine for inline ASM and intrinsics. + if (CB->isInlineAsm() || CB->getIntrinsicID() != Intrinsic::not_intrinsic) continue; SmallVector Types; @@ -6542,19 +6542,9 @@ bool X86TTIImpl::areInlineCompatible(const Function *Caller, if (all_of(Types, IsSimpleTy)) continue; - if (Function *NestedCallee = CB->getCalledFunction()) { - // Assume that intrinsics are always ABI compatible. - if (NestedCallee->isIntrinsic()) - continue; - - // Do a precise compatibility check. - if (!areTypesABICompatible(Caller, NestedCallee, Types)) - return false; - } else { - // We don't know the target features of the callee, - // assume it is incompatible. + // Do a precise compatibility check. + if (!areTypesABICompatible(Caller, Callee, Types)) return false; - } } } return true; diff --git a/llvm/test/Transforms/Inline/X86/call-abi-compatibility.ll b/llvm/test/Transforms/Inline/X86/call-abi-compatibility.ll index 6f582cab2f145..0b6c2ead58cf7 100644 --- a/llvm/test/Transforms/Inline/X86/call-abi-compatibility.ll +++ b/llvm/test/Transforms/Inline/X86/call-abi-compatibility.ll @@ -34,8 +34,7 @@ define i64 @callee_not_avx(<4 x i64> %arg) noinline { ret i64 %v } -; This call also shouldn't be inlined, as we don't know whether callee_unknown -; is ABI compatible or not. +; This call also shouldn't be inlined, as caller_not_avx2 is not ABI compatible. define void @caller_avx2() "target-features"="+avx" { ; CHECK-LABEL: define {{[^@]+}}@caller_avx2 ; CHECK-SAME: () #[[ATTR0]] { @@ -55,6 +54,29 @@ define internal void @caller_not_avx2() { ret void } +; Should be inlined, as caller_avx4 is ABI compatible. The fact that we don't +; know anything about callee_unknown doesn't matter, as it is the caller that +; determines the ABI as far as target features are concerned. +define void @caller_avx6() "target-features"="+avx" { +; CHECK-LABEL: define {{[^@]+}}@caller_avx6 +; CHECK-SAME: () #[[ATTR0]] { +; CHECK-NEXT: [[TMP1:%.*]] = call i64 @callee_unknown(<4 x i64> ) +; CHECK-NEXT: ret void +; + call void @caller_avx7() + ret void +} + +define void @caller_avx7() "target-features"="+avx" { +; CHECK-LABEL: define {{[^@]+}}@caller_avx7 +; CHECK-SAME: () #[[ATTR0]] { +; CHECK-NEXT: [[TMP1:%.*]] = call i64 @callee_unknown(<4 x i64> ) +; CHECK-NEXT: ret void +; + call i64 @callee_unknown(<4 x i64> ) + ret void +} + declare i64 @callee_unknown(<4 x i64>) ; This call should get inlined, because we assume that intrinsics are always @@ -62,20 +84,24 @@ declare i64 @callee_unknown(<4 x i64>) define void @caller_avx3() "target-features"="+avx" { ; CHECK-LABEL: define {{[^@]+}}@caller_avx3 ; CHECK-SAME: () #[[ATTR0]] { -; CHECK-NEXT: [[TMP1:%.*]] = call i64 @llvm.some_intrinsic(<4 x i64> ) +; CHECK-NEXT: [[V_I:%.*]] = load <4 x i64>, ptr @g, align 32 +; CHECK-NEXT: [[V2_I:%.*]] = call <4 x i64> @llvm.abs.v4i64(<4 x i64> [[V_I]], i1 false) +; CHECK-NEXT: store <4 x i64> [[V2_I]], ptr @g, align 32 ; CHECK-NEXT: ret void ; call void @caller_not_avx3() ret void } +@g = external global <4 x i64> + define internal void @caller_not_avx3() { - call i64 @llvm.some_intrinsic(<4 x i64> ) + %v = load <4 x i64>, ptr @g + %v2 = call <4 x i64> @llvm.abs(<4 x i64> %v, i1 false) + store <4 x i64> %v2, ptr @g ret void } -declare i64 @llvm.some_intrinsic(<4 x i64>) - ; This call should get inlined, because only simple types are involved. define void @caller_avx4() "target-features"="+avx" { ; CHECK-LABEL: define {{[^@]+}}@caller_avx4 From 26016e273df8890831b6c3e97b459b5388ffb7ef Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Thu, 7 Aug 2025 21:18:53 +0200 Subject: [PATCH 2/2] fix typo --- llvm/test/Transforms/Inline/X86/call-abi-compatibility.ll | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/test/Transforms/Inline/X86/call-abi-compatibility.ll b/llvm/test/Transforms/Inline/X86/call-abi-compatibility.ll index 0b6c2ead58cf7..9d0981cd63756 100644 --- a/llvm/test/Transforms/Inline/X86/call-abi-compatibility.ll +++ b/llvm/test/Transforms/Inline/X86/call-abi-compatibility.ll @@ -54,7 +54,7 @@ define internal void @caller_not_avx2() { ret void } -; Should be inlined, as caller_avx4 is ABI compatible. The fact that we don't +; Should be inlined, as caller_avx7 is ABI compatible. The fact that we don't ; know anything about callee_unknown doesn't matter, as it is the caller that ; determines the ABI as far as target features are concerned. define void @caller_avx6() "target-features"="+avx" {