Skip to content

[DirectX] add GEP i8 legalization #142475

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.

Sign up for GitHub

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 5 commits into from
Jun 4, 2025
Merged

[DirectX] add GEP i8 legalization #142475

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
244b01e
[DirectX] add GEP i8 legalization
farzonl Jun 2, 2025
19668a1
fix comment up, fix up some style guide reuquired changes called out …
farzonl Jun 2, 2025
6f4702a
add replaceAllUsesWith back to update old gep to new gep
farzonl Jun 3, 2025
74b05e0
Add support for GEPs with global ptr operands. Add support for loads …
farzonl Jun 3, 2025
5f1e240
make geps have array types to make the validator happy
farzonl Jun 3, 2025
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
109 changes: 100 additions & 9 deletions llvm/lib/Target/DirectX/DXILLegalizePass.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -87,20 +87,63 @@ static void fixI8UseChain(Instruction &I,
return;
}

if (auto *Load = dyn_cast<LoadInst>(&I)) {
if (!I.getType()->isIntegerTy(8))
return;
if (auto *Load = dyn_cast<LoadInst>(&I);
Load && I.getType()->isIntegerTy(8)) {
SmallVector<Value *> NewOperands;
ProcessOperands(NewOperands);
Type *ElementType = NewOperands[0]->getType();
if (auto *AI = dyn_cast<AllocaInst>(NewOperands[0]))
ElementType = AI->getAllocatedType();
if (auto *GEP = dyn_cast<GetElementPtrInst>(NewOperands[0])) {
ElementType = GEP->getSourceElementType();
if (ElementType->isArrayTy())
ElementType = ElementType->getArrayElementType();
}
LoadInst *NewLoad = Builder.CreateLoad(ElementType, NewOperands[0]);
ReplacedValues[Load] = NewLoad;
ToRemove.push_back(Load);
return;
}

if (auto *Load = dyn_cast<LoadInst>(&I);
Load && isa<ConstantExpr>(Load->getPointerOperand())) {
auto *CE = dyn_cast<ConstantExpr>(Load->getPointerOperand());
if (!(CE->getOpcode() == Instruction::GetElementPtr))
return;
auto *GEP = dyn_cast<GEPOperator>(CE);
if (!GEP->getSourceElementType()->isIntegerTy(8))
return;

Type *ElementType = Load->getType();
ConstantInt *Offset = dyn_cast<ConstantInt>(GEP->getOperand(1));
uint32_t ByteOffset = Offset->getZExtValue();
uint32_t ElemSize = Load->getDataLayout().getTypeAllocSize(ElementType);
uint32_t Index = ByteOffset / ElemSize;

Value *PtrOperand = GEP->getPointerOperand();
Type *GEPType = GEP->getPointerOperandType();

if (auto *GV = dyn_cast<GlobalVariable>(PtrOperand))
GEPType = GV->getValueType();
if (auto *AI = dyn_cast<AllocaInst>(PtrOperand))
GEPType = AI->getAllocatedType();

if (auto *ArrTy = dyn_cast<ArrayType>(GEPType))
GEPType = ArrTy;
else
GEPType = ArrayType::get(ElementType, 1); // its a scalar

Value *NewGEP = Builder.CreateGEP(
GEPType, PtrOperand, {Builder.getInt32(0), Builder.getInt32(Index)},
GEP->getName(), GEP->getNoWrapFlags());

LoadInst *NewLoad = Builder.CreateLoad(ElementType, NewGEP);
ReplacedValues[Load] = NewLoad;
Load->replaceAllUsesWith(NewLoad);
ToRemove.push_back(Load);
return;
}

if (auto *BO = dyn_cast<BinaryOperator>(&I)) {
if (!I.getType()->isIntegerTy(8))
return;
Expand Down Expand Up @@ -155,6 +198,7 @@ static void fixI8UseChain(Instruction &I,
Cast->replaceAllUsesWith(Replacement);
return;
}

Value *AdjustedCast = nullptr;
if (Cast->getOpcode() == Instruction::ZExt)
AdjustedCast = Builder.CreateZExtOrTrunc(Replacement, Cast->getType());
Expand All @@ -164,6 +208,45 @@ static void fixI8UseChain(Instruction &I,
if (AdjustedCast)
Cast->replaceAllUsesWith(AdjustedCast);
}
if (auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
if (!GEP->getType()->isPointerTy() ||
!GEP->getSourceElementType()->isIntegerTy(8))
return;

Value *BasePtr = GEP->getPointerOperand();
if (ReplacedValues.count(BasePtr))
BasePtr = ReplacedValues[BasePtr];

Type *ElementType = BasePtr->getType();

if (auto *AI = dyn_cast<AllocaInst>(BasePtr))
ElementType = AI->getAllocatedType();
if (auto *GV = dyn_cast<GlobalVariable>(BasePtr))
ElementType = GV->getValueType();

Type *GEPType = ElementType;
if (auto *ArrTy = dyn_cast<ArrayType>(ElementType))
ElementType = ArrTy->getArrayElementType();
else
GEPType = ArrayType::get(ElementType, 1); // its a scalar

ConstantInt *Offset = dyn_cast<ConstantInt>(GEP->getOperand(1));
// Note: i8 to i32 offset conversion without emitting IR requires constant
// ints. Since offset conversion is common, we can safely assume Offset is
// always a ConstantInt, so no need to have a conditional bail out on
// nullptr, instead assert this is the case.
assert(Offset && "Offset is expected to be a ConstantInt");
uint32_t ByteOffset = Offset->getZExtValue();
uint32_t ElemSize = GEP->getDataLayout().getTypeAllocSize(ElementType);
assert(ElemSize > 0 && "ElementSize must be set");
uint32_t Index = ByteOffset / ElemSize;
Value *NewGEP = Builder.CreateGEP(
GEPType, BasePtr, {Builder.getInt32(0), Builder.getInt32(Index)},
GEP->getName(), GEP->getNoWrapFlags());
ReplacedValues[GEP] = NewGEP;
GEP->replaceAllUsesWith(NewGEP);
ToRemove.push_back(GEP);
}
}

static void upcastI8AllocasAndUses(Instruction &I,
Expand All @@ -175,15 +258,12 @@ static void upcastI8AllocasAndUses(Instruction &I,

Type *SmallestType = nullptr;

for (User *U : AI->users()) {
auto *Load = dyn_cast<LoadInst>(U);
if (!Load)
continue;
auto ProcessLoad = [&](LoadInst *Load) {
for (User *LU : Load->users()) {
Type *Ty = nullptr;
if (auto *Cast = dyn_cast<CastInst>(LU))
if (CastInst *Cast = dyn_cast<CastInst>(LU))
Ty = Cast->getType();
if (CallInst *CI = dyn_cast<CallInst>(LU)) {
else if (CallInst *CI = dyn_cast<CallInst>(LU)) {
if (CI->getIntrinsicID() == Intrinsic::memset)
Ty = Type::getInt32Ty(CI->getContext());
}
Expand All @@ -195,6 +275,17 @@ static void upcastI8AllocasAndUses(Instruction &I,
Ty->getPrimitiveSizeInBits() < SmallestType->getPrimitiveSizeInBits())
SmallestType = Ty;
}
};

for (User *U : AI->users()) {
if (auto *Load = dyn_cast<LoadInst>(U))
ProcessLoad(Load);
else if (auto *GEP = dyn_cast<GetElementPtrInst>(U)) {
for (User *GU : GEP->users()) {
if (auto *Load = dyn_cast<LoadInst>(GU))
ProcessLoad(Load);
}
}
}

if (!SmallestType)
Expand Down
72 changes: 72 additions & 0 deletions llvm/test/CodeGen/DirectX/legalize-i8.ll
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -106,3 +106,75 @@ define i32 @all_imm() {
%2 = sext i8 %1 to i32
ret i32 %2
}

define i32 @scalar_i8_geps() {
; CHECK-LABEL: define i32 @scalar_i8_geps(
; CHECK-NEXT: [[ALLOCA:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds nuw [1 x i32], ptr [[ALLOCA]], i32 0, i32 0
; CHECK: [[LOAD:%.*]] = load i32, ptr [[GEP]], align 4
; CHECK-NEXT: ret i32 [[LOAD]]
%1 = alloca i8, align 4
%2 = getelementptr inbounds nuw i8, ptr %1, i32 0
%3 = load i8, ptr %2
%4 = sext i8 %3 to i32
ret i32 %4
}

define i32 @i8_geps_index0() {
; CHECK-LABEL: define i32 @i8_geps_index0(
; CHECK-NEXT: [[ALLOCA:%.*]] = alloca [2 x i32], align 8
; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds nuw [2 x i32], ptr [[ALLOCA]], i32 0, i32 0
; CHECK: [[LOAD:%.*]] = load i32, ptr [[GEP]], align 4
; CHECK-NEXT: ret i32 [[LOAD]]
%1 = alloca [2 x i32], align 8
%2 = getelementptr inbounds nuw i8, ptr %1, i32 0
%3 = load i8, ptr %2
%4 = sext i8 %3 to i32
ret i32 %4
}

define i32 @i8_geps_index1() {
; CHECK-LABEL: define i32 @i8_geps_index1(
; CHECK-NEXT: [[ALLOCA:%.*]] = alloca [2 x i32], align 8
; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds nuw [2 x i32], ptr [[ALLOCA]], i32 0, i32 1
; CHECK: [[LOAD:%.*]] = load i32, ptr [[GEP]], align 4
; CHECK-NEXT: ret i32 [[LOAD]]
%1 = alloca [2 x i32], align 8
%2 = getelementptr inbounds nuw i8, ptr %1, i32 4
%3 = load i8, ptr %2
%4 = sext i8 %3 to i32
ret i32 %4
}

define i32 @i8_gep_store() {
; CHECK-LABEL: define i32 @i8_gep_store(
; CHECK-NEXT: [[ALLOCA:%.*]] = alloca [2 x i32], align 8
; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds nuw [2 x i32], ptr [[ALLOCA]], i32 0, i32 1
; CHECK-NEXT: store i32 1, ptr [[GEP]], align 4
; CHECK: [[LOAD:%.*]] = load i32, ptr [[GEP]], align 4
; CHECK-NEXT: ret i32 [[LOAD]]
%1 = alloca [2 x i32], align 8
%2 = getelementptr inbounds nuw i8, ptr %1, i32 4
store i8 1, ptr %2
%3 = load i8, ptr %2
%4 = sext i8 %3 to i32
ret i32 %4
}

@g = local_unnamed_addr addrspace(3) global [2 x float] zeroinitializer, align 4
define float @i8_gep_global_index() {
; CHECK-LABEL: define float @i8_gep_global_index(
; CHECK-NEXT: [[LOAD:%.*]] = load float, ptr addrspace(3) getelementptr inbounds nuw ([2 x float], ptr addrspace(3) @g, i32 0, i32 1), align 4
; CHECK-NEXT: ret float [[LOAD]]
%1 = getelementptr inbounds nuw i8, ptr addrspace(3) @g, i32 4
%2 = load float, ptr addrspace(3) %1, align 4
ret float %2
}

define float @i8_gep_global_constexpr() {
; CHECK-LABEL: define float @i8_gep_global_constexpr(
; CHECK-NEXT: [[LOAD:%.*]] = load float, ptr addrspace(3) getelementptr inbounds nuw ([2 x float], ptr addrspace(3) @g, i32 0, i32 1), align 4
; CHECK-NEXT: ret float [[LOAD]]
%1 = load float, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @g, i32 4), align 4
ret float %1
}