; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
; RUN: opt -mtriple=nvptx64-nvidia-cuda -S -passes=separate-const-offset-from-gep  < %s | FileCheck %s

%struct.uchar4 = type { i8, i8, i8, i8 }

define ptr @basic(ptr %ptr, i64 %offset1, i64 %offset2) {
; CHECK-LABEL: define ptr @basic(
; CHECK-SAME: ptr [[PTR:%.*]], i64 [[OFFSET1:%.*]], i64 [[OFFSET2:%.*]]) {
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr [[STRUCT_UCHAR4:%.*]], ptr [[PTR]], i64 [[OFFSET1]]
; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr [[STRUCT_UCHAR4]], ptr [[TMP1]], i64 [[OFFSET2]]
; CHECK-NEXT:    [[GEP24:%.*]] = getelementptr i8, ptr [[TMP2]], i64 72
; CHECK-NEXT:    ret ptr [[GEP24]]
;
  %offset3 = add i64 %offset1, 8
  %gep1 = getelementptr %struct.uchar4, ptr %ptr, i64 %offset3
  %offset4 = add i64 %offset2, 10
  %gep2 = getelementptr %struct.uchar4, ptr %gep1, i64 %offset4
  ret ptr %gep2
}

define i32 @more_interesting(ptr %ptr, i32 %offset1, i32 %offset2) {
; CHECK-LABEL: define i32 @more_interesting(
; CHECK-SAME: ptr [[PTR:%.*]], i32 [[OFFSET1:%.*]], i32 [[OFFSET2:%.*]]) {
; CHECK-NEXT:    [[IDXPROM:%.*]] = sext i32 [[OFFSET1]] to i64
; CHECK-NEXT:    [[GEP1:%.*]] = getelementptr inbounds [[STRUCT_UCHAR4:%.*]], ptr [[PTR]], i64 [[IDXPROM]]
; CHECK-NEXT:    [[IDXPROM1:%.*]] = sext i32 [[OFFSET2]] to i64
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr [[STRUCT_UCHAR4]], ptr [[GEP1]], i64 [[IDXPROM1]]
; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr i8, ptr [[TMP1]], i64 8
; CHECK-NEXT:    [[V1:%.*]] = load i32, ptr [[TMP2]], align 4
; CHECK-NEXT:    [[IDXPROM2:%.*]] = sext i32 [[OFFSET2]] to i64
; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr [[STRUCT_UCHAR4]], ptr [[TMP1]], i64 [[IDXPROM2]]
; CHECK-NEXT:    [[V2:%.*]] = load i32, ptr [[TMP4]], align 4
; CHECK-NEXT:    [[R:%.*]] = add i32 [[V1]], [[V2]]
; CHECK-NEXT:    ret i32 [[R]]
;
  %gep1 = getelementptr inbounds %struct.uchar4, ptr %ptr, i32 %offset1
  %gep2 = getelementptr inbounds nuw i8, ptr %gep1, i32 8
  %gep3 = getelementptr inbounds %struct.uchar4, ptr %gep2, i32 %offset2
  %v1 = load i32, ptr %gep3, align 4
  %gep4 = getelementptr inbounds i8, ptr %gep3, i32 -8
  %gep5 = getelementptr inbounds %struct.uchar4, ptr %gep4, i32 %offset2
  %v2 = load i32, ptr %gep5, align 4
  %r = add i32 %v1, %v2
  ret i32 %r
}

;; Check nuw/nusw/inbounds flag propagation

; GEPs with nusw flag. All indices and offsets are non-negative.
define ptr @test_0(ptr %p, i32 %i) {
; CHECK-LABEL: define ptr @test_0(
; CHECK-SAME: ptr [[P:%.*]], i32 [[I:%.*]]) {
; CHECK-NEXT:    [[I_PROM:%.*]] = zext i32 [[I]] to i64
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nusw i8, ptr [[P]], i64 [[I_PROM]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nusw i8, ptr [[TMP1]], i64 2
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw inbounds i8, ptr %p, i32 1
  %i.prom = zext i32 %i to i64
  %idx2 = add i64 %i.prom, 1
  %arrayidx2 = getelementptr nusw i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with inbounds flag. All indices and offsets are non-negative.
define ptr @test_1(ptr %p, i32 %i) {
; CHECK-LABEL: define ptr @test_1(
; CHECK-SAME: ptr [[P:%.*]], i32 [[I:%.*]]) {
; CHECK-NEXT:    [[I_PROM:%.*]] = zext i32 [[I]] to i64
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[P]], i64 [[I_PROM]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr inbounds i8, ptr [[TMP1]], i64 2
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr inbounds i8, ptr %p, i32 1
  %i.prom = zext i32 %i to i64
  %idx2 = add i64 %i.prom, 1
  %arrayidx2 = getelementptr nuw inbounds i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nusw flag. All indices and offsets are non-negative.
define ptr @test_2(ptr %p, i32 %i) {
; CHECK-LABEL: define ptr @test_2(
; CHECK-SAME: ptr [[P:%.*]], i32 [[I:%.*]]) {
; CHECK-NEXT:    [[I_PROM:%.*]] = zext i32 [[I]] to i64
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nusw i8, ptr [[P]], i64 [[I_PROM]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nusw i8, ptr [[TMP1]], i64 2
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nusw i8, ptr %p, i32 1
  %i.prom = zext i32 %i to i64
  %idx2 = add nuw i64 %i.prom, 1
  %arrayidx2 = getelementptr nuw inbounds i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with inbounds flag. All indices and offsets are non-negative.
define ptr @test_3(ptr %p, i32 %i) {
; CHECK-LABEL: define ptr @test_3(
; CHECK-SAME: ptr [[P:%.*]], i32 [[I:%.*]]) {
; CHECK-NEXT:    [[I_PROM:%.*]] = zext i32 [[I]] to i64
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[P]], i64 [[I_PROM]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr inbounds i8, ptr [[TMP1]], i64 2
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw inbounds i8, ptr %p, i32 1
  %i.prom = zext i32 %i to i64
  %idx2 = add nuw i64 %i.prom, 1
  %arrayidx2 = getelementptr inbounds i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nusw flag. All indices and offsets are non-negative.
define ptr @test_4(ptr %p, i32 %i) {
; CHECK-LABEL: define ptr @test_4(
; CHECK-SAME: ptr [[P:%.*]], i32 [[I:%.*]]) {
; CHECK-NEXT:    [[I_PROM:%.*]] = zext i32 [[I]] to i64
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nusw i8, ptr [[P]], i64 [[I_PROM]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nusw i8, ptr [[TMP1]], i64 2
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw inbounds i8, ptr %p, i32 1
  %i.prom = zext i32 %i to i64
  %idx2 = add i64 %i.prom, 1
  %arrayidx2 = getelementptr nuw nusw i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with inbounds flag. All indices and offsets are non-negative.
define ptr @test_5(ptr %p, i32 %i) {
; CHECK-LABEL: define ptr @test_5(
; CHECK-SAME: ptr [[P:%.*]], i32 [[I:%.*]]) {
; CHECK-NEXT:    [[I_PROM:%.*]] = zext i32 [[I]] to i64
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[P]], i64 [[I_PROM]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr inbounds i8, ptr [[TMP1]], i64 2
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw inbounds i8, ptr %p, i32 1
  %i.prom = zext i32 %i to i64
  %idx2 = add i64 %i.prom, 1
  %arrayidx2 = getelementptr nuw inbounds i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nuw flag. Negative offsets.
define ptr @test_6(ptr %p, i64 %i) {
; CHECK-LABEL: define ptr @test_6(
; CHECK-SAME: ptr [[P:%.*]], i64 [[I:%.*]]) {
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nuw i8, ptr [[P]], i64 [[I]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nuw i8, ptr [[TMP1]], i64 -11
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw nusw i8, ptr %p, i32 -1
  %idx2 = add nuw i64 %i, -10
  %arrayidx2 = getelementptr nuw i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nuw and nusw flags. Negative offsets.
define ptr @test_7(ptr %p, i64 %i) {
; CHECK-LABEL: define ptr @test_7(
; CHECK-SAME: ptr [[P:%.*]], i64 [[I:%.*]]) {
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nusw nuw i8, ptr [[P]], i64 [[I]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nusw nuw i8, ptr [[TMP1]], i64 -11
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw inbounds i8, ptr %p, i32 -1
  %idx2 = add nuw i64 %i, -10
  %arrayidx2 = getelementptr nuw nusw i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nuw flag. Mixed positive/negative offsets.
define ptr @test_8(ptr %p, i64 %i) {
; CHECK-LABEL: define ptr @test_8(
; CHECK-SAME: ptr [[P:%.*]], i64 [[I:%.*]]) {
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nuw i8, ptr [[P]], i64 [[I]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nuw i8, ptr [[TMP1]], i64 -9
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw i8, ptr %p, i32 1
  %idx2 = add nuw i64 %i, -10
  %arrayidx2 = getelementptr nuw nusw i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nuw and nusw flags. Mixed positive/negative offsets.
define ptr @test_9(ptr %p, i64 %i) {
; CHECK-LABEL: define ptr @test_9(
; CHECK-SAME: ptr [[P:%.*]], i64 [[I:%.*]]) {
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nusw nuw i8, ptr [[P]], i64 [[I]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nusw nuw i8, ptr [[TMP1]], i64 -9
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw inbounds i8, ptr %p, i32 1
  %idx2 = add nuw i64 %i, -10
  %arrayidx2 = getelementptr nuw nusw i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nuw flag. Mixed negative/positive offsets.
define ptr @test_10(ptr %p, i64 %i) {
; CHECK-LABEL: define ptr @test_10(
; CHECK-SAME: ptr [[P:%.*]], i64 [[I:%.*]]) {
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nuw i8, ptr [[P]], i64 [[I]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nuw i8, ptr [[TMP1]], i64 9
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw i8, ptr %p, i32 -1
  %idx2 = add nuw i64 %i, 10
  %arrayidx2 = getelementptr nuw nusw i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nuw and nusw flags. Mixed negative/positive offsets.
define ptr @test_11(ptr %p, i64 %i) {
; CHECK-LABEL: define ptr @test_11(
; CHECK-SAME: ptr [[P:%.*]], i64 [[I:%.*]]) {
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nusw nuw i8, ptr [[P]], i64 [[I]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nusw nuw i8, ptr [[TMP1]], i64 9
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw inbounds i8, ptr %p, i32 -1
  %idx2 = add nuw i64 %i, 10
  %arrayidx2 = getelementptr nuw nusw i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nuw flag. All positive offsets.
define ptr @test_12(ptr %p, i64 %i) {
; CHECK-LABEL: define ptr @test_12(
; CHECK-SAME: ptr [[P:%.*]], i64 [[I:%.*]]) {
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nuw i8, ptr [[P]], i64 [[I]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nuw i8, ptr [[TMP1]], i64 2
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw nusw i8, ptr %p, i32 1
  %idx2 = add nuw i64 %i, 1
  %arrayidx2 = getelementptr nuw i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nuw and nusw flags. All positive offsets.
define ptr @test_13(ptr %p, i64 %i) {
; CHECK-LABEL: define ptr @test_13(
; CHECK-SAME: ptr [[P:%.*]], i64 [[I:%.*]]) {
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nusw nuw i8, ptr [[P]], i64 [[I]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nusw nuw i8, ptr [[TMP1]], i64 2
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw inbounds i8, ptr %p, i32 1
  %idx2 = add nuw i64 %i, 1
  %arrayidx2 = getelementptr nuw nusw i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nuw flag. Zext index with negative offsets.
define ptr @test_14(ptr %p, i32 %i) {
; CHECK-LABEL: define ptr @test_14(
; CHECK-SAME: ptr [[P:%.*]], i32 [[I:%.*]]) {
; CHECK-NEXT:    [[I_PROM:%.*]] = zext i32 [[I]] to i64
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nuw i8, ptr [[P]], i64 [[I_PROM]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nuw i8, ptr [[TMP1]], i64 -11
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw nusw i8, ptr %p, i32 -1
  %i.prom = zext i32 %i to i64
  %idx2 = add nuw i64 %i.prom, -10
  %arrayidx2 = getelementptr nuw i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nuw and nusw flags. Zext index with negative offsets.
define ptr @test_15(ptr %p, i32 %i) {
; CHECK-LABEL: define ptr @test_15(
; CHECK-SAME: ptr [[P:%.*]], i32 [[I:%.*]]) {
; CHECK-NEXT:    [[I_PROM:%.*]] = zext i32 [[I]] to i64
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nusw nuw i8, ptr [[P]], i64 [[I_PROM]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nusw nuw i8, ptr [[TMP1]], i64 -11
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw nusw i8, ptr %p, i32 -1
  %i.prom = zext i32 %i to i64
  %idx2 = add nuw i64 %i.prom, -10
  %arrayidx2 = getelementptr nuw inbounds i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nuw flag. Zext index with mixed positive/negative offsets.
define ptr @test_16(ptr %p, i32 %i) {
; CHECK-LABEL: define ptr @test_16(
; CHECK-SAME: ptr [[P:%.*]], i32 [[I:%.*]]) {
; CHECK-NEXT:    [[I_PROM:%.*]] = zext i32 [[I]] to i64
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nuw i8, ptr [[P]], i64 [[I_PROM]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nuw i8, ptr [[TMP1]], i64 -9
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw i8, ptr %p, i32 1
  %i.prom = zext i32 %i to i64
  %idx2 = add nuw i64 %i.prom, -10
  %arrayidx2 = getelementptr nuw nusw i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nuw and nusw flags. Zext index with mixed positive/negative offsets.
define ptr @test_17(ptr %p, i32 %i) {
; CHECK-LABEL: define ptr @test_17(
; CHECK-SAME: ptr [[P:%.*]], i32 [[I:%.*]]) {
; CHECK-NEXT:    [[I_PROM:%.*]] = zext i32 [[I]] to i64
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nusw nuw i8, ptr [[P]], i64 [[I_PROM]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nusw nuw i8, ptr [[TMP1]], i64 -9
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw nusw i8, ptr %p, i32 1
  %i.prom = zext i32 %i to i64
  %idx2 = add nuw i64 %i.prom, -10
  %arrayidx2 = getelementptr nuw inbounds i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nuw flag. Zext index with mixed negative/positive offsets.
define ptr @test_18(ptr %p, i32 %i) {
; CHECK-LABEL: define ptr @test_18(
; CHECK-SAME: ptr [[P:%.*]], i32 [[I:%.*]]) {
; CHECK-NEXT:    [[I_PROM:%.*]] = zext i32 [[I]] to i64
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nuw i8, ptr [[P]], i64 [[I_PROM]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nuw i8, ptr [[TMP1]], i64 9
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw nusw i8, ptr %p, i32 -1
  %i.prom = zext i32 %i to i64
  %idx2 = add nuw i64 %i.prom, 10
  %arrayidx2 = getelementptr nuw i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nuw and nusw flags. Zext index with mixed negative/positive offsets.
define ptr @test_19(ptr %p, i32 %i) {
; CHECK-LABEL: define ptr @test_19(
; CHECK-SAME: ptr [[P:%.*]], i32 [[I:%.*]]) {
; CHECK-NEXT:    [[I_PROM:%.*]] = zext i32 [[I]] to i64
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nusw nuw i8, ptr [[P]], i64 [[I_PROM]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nusw nuw i8, ptr [[TMP1]], i64 9
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw nusw i8, ptr %p, i32 -1
  %i.prom = zext i32 %i to i64
  %idx2 = add nuw i64 %i.prom, 10
  %arrayidx2 = getelementptr nuw inbounds i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nuw flag. Zext index with all positive offsets.
define ptr @test_20(ptr %p, i32 %i) {
; CHECK-LABEL: define ptr @test_20(
; CHECK-SAME: ptr [[P:%.*]], i32 [[I:%.*]]) {
; CHECK-NEXT:    [[I_PROM:%.*]] = zext i32 [[I]] to i64
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nuw i8, ptr [[P]], i64 [[I_PROM]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nuw i8, ptr [[TMP1]], i64 2
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw i8, ptr %p, i32 1
  %i.prom = zext i32 %i to i64
  %idx2 = add nuw i64 %i.prom, 1
  %arrayidx2 = getelementptr nuw nusw i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

; GEPs with nuw and nusw flags. Zext index with all positive offsets.
define ptr @test_21(ptr %p, i32 %i) {
; CHECK-LABEL: define ptr @test_21(
; CHECK-SAME: ptr [[P:%.*]], i32 [[I:%.*]]) {
; CHECK-NEXT:    [[I_PROM:%.*]] = zext i32 [[I]] to i64
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr nusw nuw i8, ptr [[P]], i64 [[I_PROM]]
; CHECK-NEXT:    [[ARRAYIDX22:%.*]] = getelementptr nusw nuw i8, ptr [[TMP1]], i64 2
; CHECK-NEXT:    ret ptr [[ARRAYIDX22]]
;
  %ptradd = getelementptr nuw inbounds i8, ptr %p, i32 1
  %i.prom = zext i32 %i to i64
  %idx2 = add nuw i64 %i.prom, 1
  %arrayidx2 = getelementptr nuw nusw i8, ptr %ptradd, i64 %idx2
  ret ptr %arrayidx2
}

define ptr @test_rpot(ptr %ptr, i64 %offset1, i64 %offset2) {
; CHECK-LABEL: define ptr @test_rpot(
; CHECK-SAME: ptr [[PTR:%.*]], i64 [[OFFSET1:%.*]], i64 [[OFFSET2:%.*]]) {
; CHECK-NEXT:  [[A:.*:]]
; CHECK-NEXT:    br label %[[B:.*]]
; CHECK:       [[C:.*]]:
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr [[STRUCT_UCHAR4:%.*]], ptr [[TMP0:%.*]], i64 [[OFFSET2]]
; CHECK-NEXT:    [[GEP24:%.*]] = getelementptr i8, ptr [[TMP1]], i64 72
; CHECK-NEXT:    br label %[[D:.*]]
; CHECK:       [[B]]:
; CHECK-NEXT:    [[TMP0]] = getelementptr [[STRUCT_UCHAR4]], ptr [[PTR]], i64 [[OFFSET1]]
; CHECK-NEXT:    br label %[[C]]
; CHECK:       [[D]]:
; CHECK-NEXT:    ret ptr [[GEP24]]
;
A:
  br label %B
C:
  %offset4 = add i64 %offset2, 10
  %gep2 = getelementptr %struct.uchar4, ptr %gep1, i64 %offset4
  br label %D
B:
  %offset3 = add i64 %offset1, 8
  %gep1 = getelementptr %struct.uchar4, ptr %ptr, i64 %offset3
  br label %C
D:
  ret ptr %gep2
}