[llvm] [DirectX] legalize memset (PR #136244)
via llvm-commits
llvm-commits at lists.llvm.org
Thu Apr 17 19:50:46 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-directx
Author: Farzon Lotfi (farzonl)
<details>
<summary>Changes</summary>
fixes #<!-- -->136243
This change converts memset into a series of geps and stores It is intentionally limited to memsets of fixed size It also converts the byte stores to type stores.
DXIL does not support i8 plus this reduces the total number of gep and store instructions.
This change also moves DXILFinalizeLinkage to run after Legalization to clean up any dead intrinsic definitions.
---
Full diff: https://github.com/llvm/llvm-project/pull/136244.diff
4 Files Affected:
- (modified) llvm/lib/Target/DirectX/DXILLegalizePass.cpp (+78)
- (modified) llvm/lib/Target/DirectX/DirectXTargetMachine.cpp (+1-1)
- (added) llvm/test/CodeGen/DirectX/legalize-memset.ll (+81)
- (modified) llvm/test/CodeGen/DirectX/llc-pipeline.ll (+1-1)
``````````diff
diff --git a/llvm/lib/Target/DirectX/DXILLegalizePass.cpp b/llvm/lib/Target/DirectX/DXILLegalizePass.cpp
index b62ff4c52f70c..d55a84d0126ec 100644
--- a/llvm/lib/Target/DirectX/DXILLegalizePass.cpp
+++ b/llvm/lib/Target/DirectX/DXILLegalizePass.cpp
@@ -12,6 +12,7 @@
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Module.h"
#include "llvm/Pass.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include <functional>
@@ -151,6 +152,82 @@ downcastI64toI32InsertExtractElements(Instruction &I,
}
}
+void emitMemset(IRBuilder<> &Builder, Value *Dst, Value *Val,
+ ConstantInt *SizeCI) {
+ LLVMContext &Ctx = Builder.getContext();
+ [[maybe_unused]] DataLayout DL =
+ Builder.GetInsertBlock()->getModule()->getDataLayout();
+ [[maybe_unused]] uint64_t OrigSize = SizeCI->getZExtValue();
+
+ AllocaInst *Alloca = dyn_cast<AllocaInst>(Dst);
+
+ assert(Alloca && "Expected memset on an Alloca");
+ assert(OrigSize == Alloca->getAllocationSize(DL)->getFixedValue() &&
+ "Expected for memset size to match DataLayout size");
+
+ Type *AllocatedTy = Alloca->getAllocatedType();
+ ArrayType *ArrTy = dyn_cast<ArrayType>(AllocatedTy);
+ assert(ArrTy && "Expected Alloca for an Array Type");
+
+ Type *ElemTy = ArrTy->getElementType();
+ uint64_t Size = ArrTy->getArrayNumElements();
+
+ [[maybe_unused]] uint64_t ElemSize = DL.getTypeStoreSize(ElemTy);
+
+ assert(ElemSize > 0 && "Size must be set");
+ assert(OrigSize == ElemSize * Size && "Size in bytes must match");
+
+ Value *TypedVal = Val;
+ if (Val->getType() != ElemTy)
+ TypedVal = Builder.CreateIntCast(Val, ElemTy,
+ false); // Or use CreateBitCast for float
+
+ for (uint64_t I = 0; I < Size; ++I) {
+ Value *Offset = ConstantInt::get(Type::getInt32Ty(Ctx), I);
+ Value *Ptr = Builder.CreateGEP(ElemTy, Dst, Offset, "gep");
+ Builder.CreateStore(TypedVal, Ptr);
+ }
+}
+
+void removeLifetimesForMemset(CallInst *Memset,
+ SmallVectorImpl<Instruction *> &ToRemove) {
+ assert(Memset->getCalledFunction()->getIntrinsicID() == Intrinsic::memset &&
+ "Expected a memset intrinsic");
+
+ Value *DstPtr = Memset->getArgOperand(0);
+ DstPtr = DstPtr->stripPointerCasts();
+
+ for (User *U : DstPtr->users()) {
+ if (auto *CI = dyn_cast<CallInst>(U)) {
+ switch (CI->getIntrinsicID()) {
+ case Intrinsic::lifetime_start:
+ case Intrinsic::lifetime_end:
+ ToRemove.push_back(CI);
+ break;
+ }
+ }
+ }
+}
+
+static void removeMemSet(Instruction &I,
+ SmallVectorImpl<Instruction *> &ToRemove,
+ DenseMap<Value *, Value *>) {
+ if (CallInst *CI = dyn_cast<CallInst>(&I)) {
+ Intrinsic::ID ID = CI->getIntrinsicID();
+ if (ID == Intrinsic::memset) {
+ IRBuilder<> Builder(&I);
+ Value *Dst = CI->getArgOperand(0);
+ Value *Val = CI->getArgOperand(1);
+ [[maybe_unused]] ConstantInt *Size =
+ dyn_cast<ConstantInt>(CI->getArgOperand(2));
+ assert(Size && "Expected Size to be a ConstantInt");
+ emitMemset(Builder, Dst, Val, Size);
+ removeLifetimesForMemset(CI, ToRemove);
+ ToRemove.push_back(CI);
+ }
+ }
+}
+
namespace {
class DXILLegalizationPipeline {
@@ -181,6 +258,7 @@ class DXILLegalizationPipeline {
LegalizationPipeline.push_back(fixI8TruncUseChain);
LegalizationPipeline.push_back(downcastI64toI32InsertExtractElements);
LegalizationPipeline.push_back(legalizeFreeze);
+ LegalizationPipeline.push_back(removeMemSet);
}
};
diff --git a/llvm/lib/Target/DirectX/DirectXTargetMachine.cpp b/llvm/lib/Target/DirectX/DirectXTargetMachine.cpp
index 41f6f37a41f9d..1cd21ae0fd55a 100644
--- a/llvm/lib/Target/DirectX/DirectXTargetMachine.cpp
+++ b/llvm/lib/Target/DirectX/DirectXTargetMachine.cpp
@@ -96,7 +96,6 @@ class DirectXPassConfig : public TargetPassConfig {
FunctionPass *createTargetRegisterAllocator(bool) override { return nullptr; }
void addCodeGenPrepare() override {
- addPass(createDXILFinalizeLinkageLegacyPass());
addPass(createDXILIntrinsicExpansionLegacyPass());
addPass(createDXILCBufferAccessLegacyPass());
addPass(createDXILDataScalarizationLegacyPass());
@@ -106,6 +105,7 @@ class DirectXPassConfig : public TargetPassConfig {
DxilScalarOptions.ScalarizeLoadStore = true;
addPass(createScalarizerPass(DxilScalarOptions));
addPass(createDXILLegalizeLegacyPass());
+ addPass(createDXILFinalizeLinkageLegacyPass());
addPass(createDXILTranslateMetadataLegacyPass());
addPass(createDXILOpLoweringLegacyPass());
addPass(createDXILPrepareModulePass());
diff --git a/llvm/test/CodeGen/DirectX/legalize-memset.ll b/llvm/test/CodeGen/DirectX/legalize-memset.ll
new file mode 100644
index 0000000000000..2d9b28753ef3d
--- /dev/null
+++ b/llvm/test/CodeGen/DirectX/legalize-memset.ll
@@ -0,0 +1,81 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
+; RUN: opt -S -passes='dxil-legalize' -mtriple=dxil-pc-shadermodel6.3-library %s | FileCheck %s
+
+
+define void @replace_float_memset_test() {
+; CHECK-LABEL: define void @replace_float_memset_test() {
+; CHECK-NEXT: [[ACCUM_I_FLAT:%.*]] = alloca [2 x float], align 4
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr float, ptr [[ACCUM_I_FLAT]], i32 0
+; CHECK-NEXT: store float 0.000000e+00, ptr [[GEP]], align 4
+; CHECK-NEXT: [[GEP1:%.*]] = getelementptr float, ptr [[ACCUM_I_FLAT]], i32 1
+; CHECK-NEXT: store float 0.000000e+00, ptr [[GEP1]], align 4
+; CHECK-NEXT: ret void
+;
+ %accum.i.flat = alloca [2 x float], align 4
+ call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %accum.i.flat)
+ call void @llvm.memset.p0.i32(ptr nonnull align 4 dereferenceable(8) %accum.i.flat, i8 0, i32 8, i1 false)
+ call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %accum.i.flat)
+ ret void
+}
+
+define void @replace_half_memset_test() {
+; CHECK-LABEL: define void @replace_half_memset_test() {
+; CHECK-NEXT: [[ACCUM_I_FLAT:%.*]] = alloca [2 x half], align 4
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr half, ptr [[ACCUM_I_FLAT]], i32 0
+; CHECK-NEXT: store half 0xH0000, ptr [[GEP]], align 2
+; CHECK-NEXT: [[GEP1:%.*]] = getelementptr half, ptr [[ACCUM_I_FLAT]], i32 1
+; CHECK-NEXT: store half 0xH0000, ptr [[GEP1]], align 2
+; CHECK-NEXT: ret void
+;
+ %accum.i.flat = alloca [2 x half], align 4
+ call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %accum.i.flat)
+ call void @llvm.memset.p0.i32(ptr nonnull align 4 dereferenceable(8) %accum.i.flat, i8 0, i32 4, i1 false)
+ call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %accum.i.flat)
+ ret void
+}
+
+define void @replace_double_memset_test() {
+; CHECK-LABEL: define void @replace_double_memset_test() {
+; CHECK-NEXT: [[ACCUM_I_FLAT:%.*]] = alloca [2 x double], align 4
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr double, ptr [[ACCUM_I_FLAT]], i32 0
+; CHECK-NEXT: store double 0.000000e+00, ptr [[GEP]], align 8
+; CHECK-NEXT: [[GEP1:%.*]] = getelementptr double, ptr [[ACCUM_I_FLAT]], i32 1
+; CHECK-NEXT: store double 0.000000e+00, ptr [[GEP1]], align 8
+; CHECK-NEXT: ret void
+;
+ %accum.i.flat = alloca [2 x double], align 4
+ call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %accum.i.flat)
+ call void @llvm.memset.p0.i32(ptr nonnull align 4 dereferenceable(8) %accum.i.flat, i8 0, i32 16, i1 false)
+ call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %accum.i.flat)
+ ret void
+}
+
+define void @replace_int16_memset_test() {
+; CHECK-LABEL: define void @replace_int16_memset_test() {
+; CHECK-NEXT: [[CACHE_I:%.*]] = alloca [2 x i16], align 2
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr i16, ptr [[CACHE_I]], i32 0
+; CHECK-NEXT: store i16 0, ptr [[GEP]], align 2
+; CHECK-NEXT: [[GEP1:%.*]] = getelementptr i16, ptr [[CACHE_I]], i32 1
+; CHECK-NEXT: store i16 0, ptr [[GEP1]], align 2
+; CHECK-NEXT: ret void
+;
+ %cache.i = alloca [2 x i16], align 2
+ call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %cache.i)
+ call void @llvm.memset.p0.i32(ptr nonnull align 2 dereferenceable(4) %cache.i, i8 0, i32 4, i1 false)
+ call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %cache.i)
+ ret void
+}
+
+define void @replace_int_memset_test() {
+; CHECK-LABEL: define void @replace_int_memset_test() {
+; CHECK-NEXT: [[ACCUM_I_FLAT:%.*]] = alloca [1 x i32], align 4
+; CHECK-NEXT: [[GEP:%.*]] = getelementptr i32, ptr [[ACCUM_I_FLAT]], i32 0
+; CHECK-NEXT: store i32 0, ptr [[GEP]], align 4
+; CHECK-NEXT: ret void
+;
+ %accum.i.flat = alloca [1 x i32], align 4
+ call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %accum.i.flat)
+ call void @llvm.memset.p0.i32(ptr nonnull align 4 dereferenceable(8) %accum.i.flat, i8 0, i32 4, i1 false)
+ call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %accum.i.flat)
+ ret void
+}
diff --git a/llvm/test/CodeGen/DirectX/llc-pipeline.ll b/llvm/test/CodeGen/DirectX/llc-pipeline.ll
index b1bd9f16f4efa..6b4a39a6d49ad 100644
--- a/llvm/test/CodeGen/DirectX/llc-pipeline.ll
+++ b/llvm/test/CodeGen/DirectX/llc-pipeline.ll
@@ -13,7 +13,6 @@
; CHECK-OBJ-NEXT: Create Garbage Collector Module Metadata
; CHECK-NEXT: ModulePass Manager
-; CHECK-NEXT: DXIL Finalize Linkage
; CHECK-NEXT: DXIL Intrinsic Expansion
; CHECK-NEXT: DXIL CBuffer Access
; CHECK-NEXT: DXIL Data Scalarization
@@ -23,6 +22,7 @@
; CHECK-NEXT: Dominator Tree Construction
; CHECK-NEXT: Scalarize vector operations
; CHECK-NEXT: DXIL Legalizer
+; CHECK-NEXT: DXIL Finalize Linkage
; CHECK-NEXT: DXIL Resource Binding Analysis
; CHECK-NEXT: DXIL Module Metadata analysis
; CHECK-NEXT: DXIL Shader Flag Analysis
``````````
</details>
https://github.com/llvm/llvm-project/pull/136244
More information about the llvm-commits
mailing list