Skip to content

[SeparateConstOffsetFromGEP] Support GEP reordering for different types #90802

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 9 commits into from
May 9, 2024
Merged

[SeparateConstOffsetFromGEP] Support GEP reordering for different types #90802

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
a8c5ae1
[SeparateConstOffsetFromGEP] Support GEP reordering for conflicting t…
jrbyrnes Apr 29, 2024
88c84fc
actually set inbounds
jrbyrnes May 2, 2024
664c92f
Review comments
jrbyrnes May 2, 2024
a4c1767
Review Comments 2
jrbyrnes May 7, 2024
a8ee263
Add Tests
jrbyrnes May 7, 2024
b371d0b
Allow ptr source type
jrbyrnes May 8, 2024
fe698dd
remove redundant test
jrbyrnes May 8, 2024
4e8a106
allow struct types
jrbyrnes May 8, 2024
15c25fe
Reorder struct types + canonicalize idx types
jrbyrnes May 8, 2024
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
28 changes: 9 additions & 19 deletions llvm/lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -972,22 +972,13 @@ SeparateConstOffsetFromGEP::lowerToArithmetics(GetElementPtrInst *Variadic,

bool SeparateConstOffsetFromGEP::reorderGEP(GetElementPtrInst *GEP,
TargetTransformInfo &TTI) {
Type *GEPType = GEP->getResultElementType();
// TODO: support reordering for non-trivial GEP chains
if (GEPType->isAggregateType() || GEP->getNumIndices() != 1)
if (GEP->getNumIndices() != 1)
return false;

auto PtrGEP = dyn_cast<GetElementPtrInst>(GEP->getPointerOperand());
if (!PtrGEP)
return false;
Type *PtrGEPType = PtrGEP->getResultElementType();
// TODO: support reordering for non-trivial GEP chains
if (PtrGEPType->isAggregateType() || PtrGEP->getNumIndices() != 1)
return false;

// TODO: support reordering for non-trivial GEP chains
if (PtrGEPType != GEPType ||
PtrGEP->getSourceElementType() != GEP->getSourceElementType())
if (PtrGEP->getNumIndices() != 1)
return false;

bool NestedNeedsExtraction;
Expand All @@ -1002,8 +993,6 @@ bool SeparateConstOffsetFromGEP::reorderGEP(GetElementPtrInst *GEP,
/*HasBaseReg=*/true, /*Scale=*/0, AddrSpace))
return false;

IRBuilder<> Builder(GEP);
Builder.SetCurrentDebugLocation(GEP->getDebugLoc());
bool GEPInBounds = GEP->isInBounds();
bool PtrGEPInBounds = PtrGEP->isInBounds();
bool IsChainInBounds = GEPInBounds && PtrGEPInBounds;
Expand All @@ -1018,13 +1007,14 @@ bool SeparateConstOffsetFromGEP::reorderGEP(GetElementPtrInst *GEP,
}
}

IRBuilder<> Builder(GEP);
// For trivial GEP chains, we can swap the indicies.
auto NewSrc = Builder.CreateGEP(PtrGEPType, PtrGEP->getPointerOperand(),
SmallVector<Value *, 4>(GEP->indices()));
cast<GetElementPtrInst>(NewSrc)->setIsInBounds(IsChainInBounds);
auto NewGEP = Builder.CreateGEP(GEPType, NewSrc,
SmallVector<Value *, 4>(PtrGEP->indices()));
cast<GetElementPtrInst>(NewGEP)->setIsInBounds(IsChainInBounds);
Value *NewSrc = Builder.CreateGEP(
GEP->getSourceElementType(), PtrGEP->getPointerOperand(),
SmallVector<Value *, 4>(GEP->indices()), "", IsChainInBounds);
Value *NewGEP = Builder.CreateGEP(PtrGEP->getSourceElementType(), NewSrc,
SmallVector<Value *, 4>(PtrGEP->indices()),
"", IsChainInBounds);
GEP->replaceAllUsesWith(NewGEP);
RecursivelyDeleteTriviallyDeadInstructions(GEP);
return true;
Expand Down
297 changes: 277 additions & 20 deletions llvm/test/Transforms/SeparateConstOffsetFromGEP/AMDGPU/reorder-gep-inbounds.ll
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,28 +1,27 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 3
; RUN: opt -mtriple=amdgcn-amd-amdhsa -mcpu=gfx90a -S -passes=separate-const-offset-from-gep < %s | FileCheck %s

define void @inboundsPossiblyNegative(ptr %in.ptr, i32 %in.idx1) {
define void @inboundsPossiblyNegative(ptr %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @inboundsPossiblyNegative(
; CHECK-SAME: ptr [[IN_PTR:%.*]], i32 [[IN_IDX1:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-SAME: ptr [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IDXPROM:%.*]] = sext i32 [[IN_IDX1]] to i64
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr <2 x i8>, ptr [[IN_PTR]], i64 [[IDXPROM]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr <2 x i8>, ptr [[TMP0]], i32 1
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr <2 x i8>, ptr [[IN_PTR]], i64 [[IN_IDX1]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr <2 x i8>, ptr [[TMP0]], i64 1
; CHECK-NEXT: ret void
;
entry:
%const1 = getelementptr inbounds <2 x i8>, ptr %in.ptr, i32 1
%idx1 = getelementptr inbounds <2 x i8>, ptr %const1, i32 %in.idx1
%const1 = getelementptr inbounds <2 x i8>, ptr %in.ptr, i64 1
%idx1 = getelementptr inbounds <2 x i8>, ptr %const1, i64 %in.idx1
ret void
}

define void @inboundsNonNegative(ptr %in.ptr, i32 %in.idx1) {
; CHECK-LABEL: define void @inboundsNonNegative(
define void @inboundsNonNegative_nonCanonical(ptr %in.ptr, i32 %in.idx1) {
; CHECK-LABEL: define void @inboundsNonNegative_nonCanonical(
; CHECK-SAME: ptr [[IN_PTR:%.*]], i32 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IN_IDX1_NNEG:%.*]] = and i32 [[IN_IDX1]], 2147483647
; CHECK-NEXT: [[IDXPROM:%.*]] = sext i32 [[IN_IDX1_NNEG]] to i64
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds <2 x i8>, ptr [[IN_PTR]], i64 [[IDXPROM]]
; CHECK-NEXT: [[IN_IDX1_NNEG1:%.*]] = and i32 [[IN_IDX1]], 2147483647
; CHECK-NEXT: [[IN_IDX1_NNEG:%.*]] = sext i32 [[IN_IDX1_NNEG1]] to i64
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds <2 x i8>, ptr [[IN_PTR]], i64 [[IN_IDX1_NNEG]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds <2 x i8>, ptr [[TMP0]], i32 1
; CHECK-NEXT: ret void
;
Expand All @@ -33,19 +32,277 @@ entry:
ret void
}

define void @inboundsNonchained(ptr %in.ptr, i32 %in.idx1) {
define void @inboundsNonNegative(ptr %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @inboundsNonNegative(
; CHECK-SAME: ptr [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IDXPROM:%.*]] = and i64 [[IN_IDX1]], 9223372036854775807
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds <2 x i8>, ptr [[IN_PTR]], i64 [[IDXPROM]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds <2 x i8>, ptr [[TMP0]], i64 1
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i64 %in.idx1, 9223372036854775807
%const1 = getelementptr inbounds <2 x i8>, ptr %in.ptr, i64 1
%idx1 = getelementptr inbounds <2 x i8>, ptr %const1, i64 %in.idx1.nneg
ret void
}

define void @inboundsNonchained(ptr %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @inboundsNonchained(
; CHECK-SAME: ptr [[IN_PTR:%.*]], i32 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-SAME: ptr [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IN_IDX1_NNEG:%.*]] = and i32 [[IN_IDX1]], 2147483647
; CHECK-NEXT: [[IDXPROM:%.*]] = sext i32 [[IN_IDX1_NNEG]] to i64
; CHECK-NEXT: [[IDXPROM:%.*]] = and i64 [[IN_IDX1]], 9223372036854775807
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr <2 x i8>, ptr [[IN_PTR]], i64 [[IDXPROM]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr <2 x i8>, ptr [[TMP0]], i32 1
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr <2 x i8>, ptr [[TMP0]], i64 1
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i32 %in.idx1, 2147483647
%const1 = getelementptr inbounds <2 x i8>, ptr %in.ptr, i32 1
%idx1 = getelementptr <2 x i8>, ptr %const1, i32 %in.idx1.nneg
%in.idx1.nneg = and i64 %in.idx1, 9223372036854775807
%const1 = getelementptr inbounds <2 x i8>, ptr %in.ptr, i64 1
%idx1 = getelementptr <2 x i8>, ptr %const1, i64 %in.idx1.nneg
ret void
}

define void @inboundsNonNegativeType_i16i8(ptr %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @inboundsNonNegativeType_i16i8(
; CHECK-SAME: ptr [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IDXPROM:%.*]] = and i64 [[IN_IDX1]], 9223372036854775807
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds i8, ptr [[IN_PTR]], i64 [[IDXPROM]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i16, ptr [[TMP0]], i64 1024
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i64 %in.idx1, 9223372036854775807
%const1 = getelementptr inbounds i16, ptr %in.ptr, i64 1024
%idx1 = getelementptr inbounds i8, ptr %const1, i64 %in.idx1.nneg
ret void
}

define void @inboundsNonNegative_i8i16(ptr %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @inboundsNonNegative_i8i16(
; CHECK-SAME: ptr [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IDXPROM:%.*]] = and i64 [[IN_IDX1]], 9223372036854775807
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds i16, ptr [[IN_PTR]], i64 [[IDXPROM]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[TMP0]], i64 1024
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i64 %in.idx1, 9223372036854775807
%const1 = getelementptr inbounds i8, ptr %in.ptr, i64 1024
%idx1 = getelementptr inbounds i16, ptr %const1, i64 %in.idx1.nneg
ret void
}

define void @inboundsNonchained_first(ptr %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @inboundsNonchained_first(
; CHECK-SAME: ptr [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IN_IDX1_NNEG:%.*]] = and i64 [[IN_IDX1]], 9223372036854775807
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr i32, ptr [[IN_PTR]], i64 [[IN_IDX1_NNEG]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[TMP0]], i64 1024
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i64 %in.idx1, 9223372036854775807
%const1 = getelementptr inbounds i8, ptr %in.ptr, i64 1024
%idx1 = getelementptr i32, ptr %const1, i64 %in.idx1.nneg
ret void
}

define void @inboundsNonchained_second(ptr %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @inboundsNonchained_second(
; CHECK-SAME: ptr [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IN_IDX1_NNEG:%.*]] = and i64 [[IN_IDX1]], 9223372036854775807
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr i64, ptr [[IN_PTR]], i64 [[IN_IDX1_NNEG]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[TMP0]], i64 1024
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i64 %in.idx1, 9223372036854775807
%const1 = getelementptr i8, ptr %in.ptr, i64 1024
%idx1 = getelementptr inbounds i64, ptr %const1, i64 %in.idx1.nneg
ret void
}

define void @notInbounds(ptr %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @notInbounds(
; CHECK-SAME: ptr [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IN_IDX1_NNEG:%.*]] = and i64 [[IN_IDX1]], 9223372036854775807
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr i128, ptr [[IN_PTR]], i64 [[IN_IDX1_NNEG]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[TMP0]], i64 1024
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i64 %in.idx1, 9223372036854775807
%const1 = getelementptr i8, ptr %in.ptr, i64 1024
%idx1 = getelementptr i128, ptr %const1, i64 %in.idx1.nneg
ret void
}

define void @vectorType1(ptr %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @vectorType1(
; CHECK-SAME: ptr [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IN_IDX1_NNEG:%.*]] = and i64 [[IN_IDX1]], 2147483647
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds <2 x i8>, ptr [[IN_PTR]], i64 [[IN_IDX1_NNEG]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds <4 x i8>, ptr [[TMP0]], i32 3
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i64 %in.idx1, 2147483647
%const1 = getelementptr inbounds <4 x i8>, ptr %in.ptr, i32 3
%idx1 = getelementptr inbounds <2 x i8>, ptr %const1, i64 %in.idx1.nneg
ret void
}

define void @vectorType2(ptr %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @vectorType2(
; CHECK-SAME: ptr [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IN_IDX1_NNEG:%.*]] = and i64 [[IN_IDX1]], 2147483647
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds <4 x half>, ptr [[IN_PTR]], i64 [[IN_IDX1_NNEG]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds <4 x i8>, ptr [[TMP0]], i32 1
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i64 %in.idx1, 2147483647
%const1 = getelementptr inbounds <4 x i8>, ptr %in.ptr, i32 1
%idx1 = getelementptr inbounds <4 x half>, ptr %const1, i64 %in.idx1.nneg
ret void
}

define void @vectorType3(ptr %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @vectorType3(
; CHECK-SAME: ptr [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IN_IDX1_NNEG:%.*]] = and i64 [[IN_IDX1]], 2147483647
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds ptr, ptr [[IN_PTR]], i64 [[IN_IDX1_NNEG]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds <4 x ptr>, ptr [[TMP0]], i32 1
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i64 %in.idx1, 2147483647
%const1 = getelementptr inbounds <4 x ptr>, ptr %in.ptr, i32 1
%idx1 = getelementptr inbounds ptr, ptr %const1, i64 %in.idx1.nneg
ret void
}

define void @vectorType4(ptr %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @vectorType4(
; CHECK-SAME: ptr [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IN_IDX1_NNEG:%.*]] = and i64 [[IN_IDX1]], 2147483647
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds <8 x ptr addrspace(1)>, ptr [[IN_PTR]], i64 [[IN_IDX1_NNEG]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds <4 x ptr>, ptr [[TMP0]], i32 3
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i64 %in.idx1, 2147483647
%const1 = getelementptr inbounds <4 x ptr>, ptr %in.ptr, i32 3
%idx1 = getelementptr inbounds <8 x ptr addrspace(1)>, ptr %const1, i64 %in.idx1.nneg
ret void
}


define void @ptrType(ptr %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @ptrType(
; CHECK-SAME: ptr [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IN_IDX1_NNEG:%.*]] = and i64 [[IN_IDX1]], 2147483647
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds ptr, ptr [[IN_PTR]], i64 [[IN_IDX1_NNEG]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds ptr addrspace(2), ptr [[TMP0]], i32 1
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i64 %in.idx1, 2147483647
%const1 = getelementptr inbounds ptr addrspace(2), ptr %in.ptr, i32 1
%idx1 = getelementptr inbounds ptr, ptr %const1, i64 %in.idx1.nneg
ret void
}

define void @ptrType2(ptr %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @ptrType2(
; CHECK-SAME: ptr [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IN_IDX1_NNEG:%.*]] = and i64 [[IN_IDX1]], 2147483647
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds i64, ptr [[IN_PTR]], i64 [[IN_IDX1_NNEG]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds ptr addrspace(3), ptr [[TMP0]], i32 3
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i64 %in.idx1, 2147483647
%const1 = getelementptr inbounds ptr addrspace(3), ptr %in.ptr, i32 3
%idx1 = getelementptr inbounds i64, ptr %const1, i64 %in.idx1.nneg
ret void
}

define void @ptrType3(ptr %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @ptrType3(
; CHECK-SAME: ptr [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IN_IDX1_NNEG:%.*]] = and i64 [[IN_IDX1]], 2147483647
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds i16, ptr [[IN_PTR]], i64 [[IN_IDX1_NNEG]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds ptr addrspace(7), ptr [[TMP0]], i32 3
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i64 %in.idx1, 2147483647
%const1 = getelementptr inbounds ptr addrspace(7), ptr %in.ptr, i32 3
%idx1 = getelementptr inbounds i16, ptr %const1, i64 %in.idx1.nneg
ret void
}

define void @addrspace1(ptr addrspace(1) %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @addrspace1(
; CHECK-SAME: ptr addrspace(1) [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IN_IDX1_NNEG:%.*]] = and i64 [[IN_IDX1]], 9223372036854775807
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds i128, ptr addrspace(1) [[IN_PTR]], i64 [[IN_IDX1_NNEG]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[TMP0]], i64 1024
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i64 %in.idx1, 9223372036854775807
%const1 = getelementptr inbounds i8, ptr addrspace(1) %in.ptr, i64 1024
%idx1 = getelementptr inbounds i128, ptr addrspace(1) %const1, i64 %in.idx1.nneg
ret void
}

define void @addrspace3(ptr addrspace(3) %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @addrspace3(
; CHECK-SAME: ptr addrspace(3) [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IN_IDX1_NNEG:%.*]] = and i64 [[IN_IDX1]], 9223372036854775807
; CHECK-NEXT: [[IDXPROM:%.*]] = trunc i64 [[IN_IDX1_NNEG]] to i32
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr i128, ptr addrspace(3) [[IN_PTR]], i32 [[IDXPROM]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr addrspace(3) [[TMP0]], i64 1024
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i64 %in.idx1, 9223372036854775807
%const1 = getelementptr inbounds i8, ptr addrspace(3) %in.ptr, i64 1024
%idx1 = getelementptr inbounds i128, ptr addrspace(3) %const1, i64 %in.idx1.nneg
ret void
}

define void @addrspace7(ptr addrspace(7) %in.ptr, i64 %in.idx1) {
; CHECK-LABEL: define void @addrspace7(
; CHECK-SAME: ptr addrspace(7) [[IN_PTR:%.*]], i64 [[IN_IDX1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[IN_IDX1_NNEG:%.*]] = and i64 [[IN_IDX1]], 9223372036854775807
; CHECK-NEXT: [[IDXPROM:%.*]] = trunc i64 [[IN_IDX1_NNEG]] to i32
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr i128, ptr addrspace(7) [[IN_PTR]], i32 [[IDXPROM]]
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr addrspace(7) [[TMP0]], i64 1024
; CHECK-NEXT: ret void
;
entry:
%in.idx1.nneg = and i64 %in.idx1, 9223372036854775807
%const1 = getelementptr inbounds i8, ptr addrspace(7) %in.ptr, i64 1024
%idx1 = getelementptr inbounds i128, ptr addrspace(7) %const1, i64 %in.idx1.nneg
ret void
}
Loading
Loading