; The transformation is failed with this test because we can not guarantee the
; split condition is always true in pre-loop after transformation.
-define void @variable_split_loop_bound_and_exit_cond_inc_with_sgt(i64 %a, i64* noalias %src, i64* noalias %dst, i64 %n) {
+define void @variable_split_loop_bound_and_exit_cond_inc_with_sgt(i64 %a, ptr noalias %src, ptr noalias %dst, i64 %n) {
; CHECK-LABEL: @variable_split_loop_bound_and_exit_cond_inc_with_sgt(
; CHECK-NEXT: loop.ph:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i64 [[IV]], [[A:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[SRC:%.*]], i64 [[IV]]
-; CHECK-NEXT: [[VAL:%.*]] = load i64, i64* [[SRC_ARRAYIDX]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[DST:%.*]], i64 [[IV]]
-; CHECK-NEXT: store i64 [[VAL]], i64* [[DST_ARRAYIDX]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[SRC:%.*]], i64 [[IV]]
+; CHECK-NEXT: [[VAL:%.*]] = load i64, ptr [[SRC_ARRAYIDX]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[DST:%.*]], i64 [[IV]]
+; CHECK-NEXT: store i64 [[VAL]], ptr [[DST_ARRAYIDX]], align 4
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: if.else:
; CHECK-NEXT: br label [[FOR_INC]]
br i1 %cmp, label %if.then, label %if.else
if.then:
- %src.arrayidx = getelementptr inbounds i64, i64* %src, i64 %iv
- %val = load i64, i64* %src.arrayidx
- %dst.arrayidx = getelementptr inbounds i64, i64* %dst, i64 %iv
- store i64 %val, i64* %dst.arrayidx
+ %src.arrayidx = getelementptr inbounds i64, ptr %src, i64 %iv
+ %val = load i64, ptr %src.arrayidx
+ %dst.arrayidx = getelementptr inbounds i64, ptr %dst, i64 %iv
+ store i64 %val, ptr %dst.arrayidx
br label %for.inc
if.else:
; The transformation works with this test because we can guarantee the split
; condition is always true in pre-loop after transformation.
-define void @umax_variable_split_loop_bound_and_exit_cond_inc_with_sgt(i64 %a, i64* noalias %src, i64* noalias %dst, i64 %n) {
+define void @umax_variable_split_loop_bound_and_exit_cond_inc_with_sgt(i64 %a, ptr noalias %src, ptr noalias %dst, i64 %n) {
; CHECK-LABEL: @umax_variable_split_loop_bound_and_exit_cond_inc_with_sgt(
; CHECK-NEXT: loop.ph:
; CHECK-NEXT: [[B:%.*]] = call i64 @llvm.umax.i64(i64 [[A:%.*]], i64 1)
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i64 [[IV]], [[B]]
; CHECK-NEXT: br i1 true, label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[SRC:%.*]], i64 [[IV]]
-; CHECK-NEXT: [[VAL:%.*]] = load i64, i64* [[SRC_ARRAYIDX]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[DST:%.*]], i64 [[IV]]
-; CHECK-NEXT: store i64 [[VAL]], i64* [[DST_ARRAYIDX]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[SRC:%.*]], i64 [[IV]]
+; CHECK-NEXT: [[VAL:%.*]] = load i64, ptr [[SRC_ARRAYIDX]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[DST:%.*]], i64 [[IV]]
+; CHECK-NEXT: store i64 [[VAL]], ptr [[DST_ARRAYIDX]], align 4
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: if.else:
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: if.else.split:
; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: if.then.split:
-; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, i64* [[SRC]], i64 [[IV_SPLIT]]
-; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, i64* [[SRC_ARRAYIDX_SPLIT]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, i64* [[DST]], i64 [[IV_SPLIT]]
-; CHECK-NEXT: store i64 [[VAL_SPLIT]], i64* [[DST_ARRAYIDX_SPLIT]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]]
+; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]]
+; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: for.inc.split:
; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 1
br i1 %cmp, label %if.then, label %if.else
if.then:
- %src.arrayidx = getelementptr inbounds i64, i64* %src, i64 %iv
- %val = load i64, i64* %src.arrayidx
- %dst.arrayidx = getelementptr inbounds i64, i64* %dst, i64 %iv
- store i64 %val, i64* %dst.arrayidx
+ %src.arrayidx = getelementptr inbounds i64, ptr %src, i64 %iv
+ %val = load i64, ptr %src.arrayidx
+ %dst.arrayidx = getelementptr inbounds i64, ptr %dst, i64 %iv
+ store i64 %val, ptr %dst.arrayidx
br label %for.inc
if.else:
; The transformation works with this test because we can guarantee the split
; condition is always true in pre-loop after transformation.
-define void @constant_split_loop_bound_and_exit_cond_inc_with_sgt(i64* noalias %src, i64* noalias %dst, i64 %n) {
+define void @constant_split_loop_bound_and_exit_cond_inc_with_sgt(ptr noalias %src, ptr noalias %dst, i64 %n) {
; CHECK-LABEL: @constant_split_loop_bound_and_exit_cond_inc_with_sgt(
; CHECK-NEXT: loop.ph:
; CHECK-NEXT: br label [[LOOP_PH_SPLIT:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i64 [[IV]], 10
; CHECK-NEXT: br i1 true, label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[SRC:%.*]], i64 [[IV]]
-; CHECK-NEXT: [[VAL:%.*]] = load i64, i64* [[SRC_ARRAYIDX]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[DST:%.*]], i64 [[IV]]
-; CHECK-NEXT: store i64 [[VAL]], i64* [[DST_ARRAYIDX]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[SRC:%.*]], i64 [[IV]]
+; CHECK-NEXT: [[VAL:%.*]] = load i64, ptr [[SRC_ARRAYIDX]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[DST:%.*]], i64 [[IV]]
+; CHECK-NEXT: store i64 [[VAL]], ptr [[DST_ARRAYIDX]], align 4
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: if.else:
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: if.else.split:
; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: if.then.split:
-; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, i64* [[SRC]], i64 [[IV_SPLIT]]
-; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, i64* [[SRC_ARRAYIDX_SPLIT]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, i64* [[DST]], i64 [[IV_SPLIT]]
-; CHECK-NEXT: store i64 [[VAL_SPLIT]], i64* [[DST_ARRAYIDX_SPLIT]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]]
+; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]]
+; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: for.inc.split:
; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 1
br i1 %cmp, label %if.then, label %if.else
if.then:
- %src.arrayidx = getelementptr inbounds i64, i64* %src, i64 %iv
- %val = load i64, i64* %src.arrayidx
- %dst.arrayidx = getelementptr inbounds i64, i64* %dst, i64 %iv
- store i64 %val, i64* %dst.arrayidx
+ %src.arrayidx = getelementptr inbounds i64, ptr %src, i64 %iv
+ %val = load i64, ptr %src.arrayidx
+ %dst.arrayidx = getelementptr inbounds i64, ptr %dst, i64 %iv
+ store i64 %val, ptr %dst.arrayidx
br label %for.inc
if.else:
ret void
}
-define void @variable_split_loop_bound_and_exit_cond_inc_with_eq(i64 %a, i64* noalias %src, i64* noalias %dst, i64 %n) {
+define void @variable_split_loop_bound_and_exit_cond_inc_with_eq(i64 %a, ptr noalias %src, ptr noalias %dst, i64 %n) {
; CHECK-LABEL: @variable_split_loop_bound_and_exit_cond_inc_with_eq(
; CHECK-NEXT: loop.ph:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i64 [[IV]], [[A:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[SRC:%.*]], i64 [[IV]]
-; CHECK-NEXT: [[VAL:%.*]] = load i64, i64* [[SRC_ARRAYIDX]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[DST:%.*]], i64 [[IV]]
-; CHECK-NEXT: store i64 [[VAL]], i64* [[DST_ARRAYIDX]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[SRC:%.*]], i64 [[IV]]
+; CHECK-NEXT: [[VAL:%.*]] = load i64, ptr [[SRC_ARRAYIDX]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[DST:%.*]], i64 [[IV]]
+; CHECK-NEXT: store i64 [[VAL]], ptr [[DST_ARRAYIDX]], align 4
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: if.else:
; CHECK-NEXT: br label [[FOR_INC]]
br i1 %cmp, label %if.then, label %if.else
if.then:
- %src.arrayidx = getelementptr inbounds i64, i64* %src, i64 %iv
- %val = load i64, i64* %src.arrayidx
- %dst.arrayidx = getelementptr inbounds i64, i64* %dst, i64 %iv
- store i64 %val, i64* %dst.arrayidx
+ %src.arrayidx = getelementptr inbounds i64, ptr %src, i64 %iv
+ %val = load i64, ptr %src.arrayidx
+ %dst.arrayidx = getelementptr inbounds i64, ptr %dst, i64 %iv
+ store i64 %val, ptr %dst.arrayidx
br label %for.inc
if.else:
ret void
}
-define void @constant_split_loop_bound_and_exit_cond_inc_with_eq(i64* noalias %src, i64* noalias %dst, i64 %n) {
+define void @constant_split_loop_bound_and_exit_cond_inc_with_eq(ptr noalias %src, ptr noalias %dst, i64 %n) {
; CHECK-LABEL: @constant_split_loop_bound_and_exit_cond_inc_with_eq(
; CHECK-NEXT: loop.ph:
; CHECK-NEXT: br label [[LOOP_PH_SPLIT:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i64 [[IV]], 10
; CHECK-NEXT: br i1 true, label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[SRC:%.*]], i64 [[IV]]
-; CHECK-NEXT: [[VAL:%.*]] = load i64, i64* [[SRC_ARRAYIDX]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[DST:%.*]], i64 [[IV]]
-; CHECK-NEXT: store i64 [[VAL]], i64* [[DST_ARRAYIDX]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[SRC:%.*]], i64 [[IV]]
+; CHECK-NEXT: [[VAL:%.*]] = load i64, ptr [[SRC_ARRAYIDX]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[DST:%.*]], i64 [[IV]]
+; CHECK-NEXT: store i64 [[VAL]], ptr [[DST_ARRAYIDX]], align 4
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: if.else:
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: if.else.split:
; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: if.then.split:
-; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, i64* [[SRC]], i64 [[IV_SPLIT]]
-; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, i64* [[SRC_ARRAYIDX_SPLIT]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, i64* [[DST]], i64 [[IV_SPLIT]]
-; CHECK-NEXT: store i64 [[VAL_SPLIT]], i64* [[DST_ARRAYIDX_SPLIT]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]]
+; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]]
+; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: for.inc.split:
; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 1
br i1 %cmp, label %if.then, label %if.else
if.then:
- %src.arrayidx = getelementptr inbounds i64, i64* %src, i64 %iv
- %val = load i64, i64* %src.arrayidx
- %dst.arrayidx = getelementptr inbounds i64, i64* %dst, i64 %iv
- store i64 %val, i64* %dst.arrayidx
+ %src.arrayidx = getelementptr inbounds i64, ptr %src, i64 %iv
+ %val = load i64, ptr %src.arrayidx
+ %dst.arrayidx = getelementptr inbounds i64, ptr %dst, i64 %iv
+ store i64 %val, ptr %dst.arrayidx
br label %for.inc
if.else:
ret void
}
-define void @variable_split_loop_bound_and_exit_cond_inc_with_sge(i64 %a, i64* noalias %src, i64* noalias %dst, i64 %n) {
+define void @variable_split_loop_bound_and_exit_cond_inc_with_sge(i64 %a, ptr noalias %src, ptr noalias %dst, i64 %n) {
; CHECK-LABEL: @variable_split_loop_bound_and_exit_cond_inc_with_sge(
; CHECK-NEXT: loop.ph:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i64 [[IV]], [[A:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[SRC:%.*]], i64 [[IV]]
-; CHECK-NEXT: [[VAL:%.*]] = load i64, i64* [[SRC_ARRAYIDX]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[DST:%.*]], i64 [[IV]]
-; CHECK-NEXT: store i64 [[VAL]], i64* [[DST_ARRAYIDX]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[SRC:%.*]], i64 [[IV]]
+; CHECK-NEXT: [[VAL:%.*]] = load i64, ptr [[SRC_ARRAYIDX]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[DST:%.*]], i64 [[IV]]
+; CHECK-NEXT: store i64 [[VAL]], ptr [[DST_ARRAYIDX]], align 4
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: if.else:
; CHECK-NEXT: br label [[FOR_INC]]
br i1 %cmp, label %if.then, label %if.else
if.then:
- %src.arrayidx = getelementptr inbounds i64, i64* %src, i64 %iv
- %val = load i64, i64* %src.arrayidx
- %dst.arrayidx = getelementptr inbounds i64, i64* %dst, i64 %iv
- store i64 %val, i64* %dst.arrayidx
+ %src.arrayidx = getelementptr inbounds i64, ptr %src, i64 %iv
+ %val = load i64, ptr %src.arrayidx
+ %dst.arrayidx = getelementptr inbounds i64, ptr %dst, i64 %iv
+ store i64 %val, ptr %dst.arrayidx
br label %for.inc
if.else:
ret void
}
-define void @constant_split_loop_bound_and_exit_cond_inc_with_sge(i64* noalias %src, i64* noalias %dst, i64 %n) {
+define void @constant_split_loop_bound_and_exit_cond_inc_with_sge(ptr noalias %src, ptr noalias %dst, i64 %n) {
; CHECK-LABEL: @constant_split_loop_bound_and_exit_cond_inc_with_sge(
; CHECK-NEXT: loop.ph:
; CHECK-NEXT: br label [[LOOP_PH_SPLIT:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i64 [[IV]], 10
; CHECK-NEXT: br i1 true, label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[SRC:%.*]], i64 [[IV]]
-; CHECK-NEXT: [[VAL:%.*]] = load i64, i64* [[SRC_ARRAYIDX]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[DST:%.*]], i64 [[IV]]
-; CHECK-NEXT: store i64 [[VAL]], i64* [[DST_ARRAYIDX]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[SRC:%.*]], i64 [[IV]]
+; CHECK-NEXT: [[VAL:%.*]] = load i64, ptr [[SRC_ARRAYIDX]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[DST:%.*]], i64 [[IV]]
+; CHECK-NEXT: store i64 [[VAL]], ptr [[DST_ARRAYIDX]], align 4
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: if.else:
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: if.else.split:
; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: if.then.split:
-; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, i64* [[SRC]], i64 [[IV_SPLIT]]
-; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, i64* [[SRC_ARRAYIDX_SPLIT]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, i64* [[DST]], i64 [[IV_SPLIT]]
-; CHECK-NEXT: store i64 [[VAL_SPLIT]], i64* [[DST_ARRAYIDX_SPLIT]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]]
+; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]]
+; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: for.inc.split:
; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 1
br i1 %cmp, label %if.then, label %if.else
if.then:
- %src.arrayidx = getelementptr inbounds i64, i64* %src, i64 %iv
- %val = load i64, i64* %src.arrayidx
- %dst.arrayidx = getelementptr inbounds i64, i64* %dst, i64 %iv
- store i64 %val, i64* %dst.arrayidx
+ %src.arrayidx = getelementptr inbounds i64, ptr %src, i64 %iv
+ %val = load i64, ptr %src.arrayidx
+ %dst.arrayidx = getelementptr inbounds i64, ptr %dst, i64 %iv
+ store i64 %val, ptr %dst.arrayidx
br label %for.inc
if.else:
ret void
}
-define void @variable_split_loop_bound_and_exit_cond_inc_with_step_is_not_one(i64 %a, i64* noalias %src, i64* noalias %dst, i64 %n) {
+define void @variable_split_loop_bound_and_exit_cond_inc_with_step_is_not_one(i64 %a, ptr noalias %src, ptr noalias %dst, i64 %n) {
; CHECK-LABEL: @variable_split_loop_bound_and_exit_cond_inc_with_step_is_not_one(
; CHECK-NEXT: loop.ph:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i64 [[IV]], [[A:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[SRC:%.*]], i64 [[IV]]
-; CHECK-NEXT: [[VAL:%.*]] = load i64, i64* [[SRC_ARRAYIDX]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[DST:%.*]], i64 [[IV]]
-; CHECK-NEXT: store i64 [[VAL]], i64* [[DST_ARRAYIDX]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[SRC:%.*]], i64 [[IV]]
+; CHECK-NEXT: [[VAL:%.*]] = load i64, ptr [[SRC_ARRAYIDX]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[DST:%.*]], i64 [[IV]]
+; CHECK-NEXT: store i64 [[VAL]], ptr [[DST_ARRAYIDX]], align 4
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: if.else:
; CHECK-NEXT: br label [[FOR_INC]]
br i1 %cmp, label %if.then, label %if.else
if.then:
- %src.arrayidx = getelementptr inbounds i64, i64* %src, i64 %iv
- %val = load i64, i64* %src.arrayidx
- %dst.arrayidx = getelementptr inbounds i64, i64* %dst, i64 %iv
- store i64 %val, i64* %dst.arrayidx
+ %src.arrayidx = getelementptr inbounds i64, ptr %src, i64 %iv
+ %val = load i64, ptr %src.arrayidx
+ %dst.arrayidx = getelementptr inbounds i64, ptr %dst, i64 %iv
+ store i64 %val, ptr %dst.arrayidx
br label %for.inc
if.else:
ret void
}
-define void @constant_split_loop_bound_and_exit_cond_inc_with_step_is_not_one(i64* noalias %src, i64* noalias %dst, i64 %n) {
+define void @constant_split_loop_bound_and_exit_cond_inc_with_step_is_not_one(ptr noalias %src, ptr noalias %dst, i64 %n) {
; CHECK-LABEL: @constant_split_loop_bound_and_exit_cond_inc_with_step_is_not_one(
; CHECK-NEXT: loop.ph:
; CHECK-NEXT: br label [[LOOP_PH_SPLIT:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i64 [[IV]], 10
; CHECK-NEXT: br i1 true, label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[SRC:%.*]], i64 [[IV]]
-; CHECK-NEXT: [[VAL:%.*]] = load i64, i64* [[SRC_ARRAYIDX]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[DST:%.*]], i64 [[IV]]
-; CHECK-NEXT: store i64 [[VAL]], i64* [[DST_ARRAYIDX]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[SRC:%.*]], i64 [[IV]]
+; CHECK-NEXT: [[VAL:%.*]] = load i64, ptr [[SRC_ARRAYIDX]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[DST:%.*]], i64 [[IV]]
+; CHECK-NEXT: store i64 [[VAL]], ptr [[DST_ARRAYIDX]], align 4
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: if.else:
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: if.else.split:
; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: if.then.split:
-; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, i64* [[SRC]], i64 [[IV_SPLIT]]
-; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, i64* [[SRC_ARRAYIDX_SPLIT]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, i64* [[DST]], i64 [[IV_SPLIT]]
-; CHECK-NEXT: store i64 [[VAL_SPLIT]], i64* [[DST_ARRAYIDX_SPLIT]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]]
+; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]]
+; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: for.inc.split:
; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 2
br i1 %cmp, label %if.then, label %if.else
if.then:
- %src.arrayidx = getelementptr inbounds i64, i64* %src, i64 %iv
- %val = load i64, i64* %src.arrayidx
- %dst.arrayidx = getelementptr inbounds i64, i64* %dst, i64 %iv
- store i64 %val, i64* %dst.arrayidx
+ %src.arrayidx = getelementptr inbounds i64, ptr %src, i64 %iv
+ %val = load i64, ptr %src.arrayidx
+ %dst.arrayidx = getelementptr inbounds i64, ptr %dst, i64 %iv
+ store i64 %val, ptr %dst.arrayidx
br label %for.inc
if.else:
ret void
}
-define void @variable_split_loop_bound_and_exit_cond_inc_with_ne(i64 %a, i64* noalias %src, i64* noalias %dst, i64 %n) {
+define void @variable_split_loop_bound_and_exit_cond_inc_with_ne(i64 %a, ptr noalias %src, ptr noalias %dst, i64 %n) {
; CHECK-LABEL: @variable_split_loop_bound_and_exit_cond_inc_with_ne(
; CHECK-NEXT: loop.ph:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i64 [[IV]], [[A:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[FOR_INC]]
; CHECK: if.then:
-; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[SRC:%.*]], i64 [[IV]]
-; CHECK-NEXT: [[VAL:%.*]] = load i64, i64* [[SRC_ARRAYIDX]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[DST:%.*]], i64 [[IV]]
-; CHECK-NEXT: store i64 [[VAL]], i64* [[DST_ARRAYIDX]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[SRC:%.*]], i64 [[IV]]
+; CHECK-NEXT: [[VAL:%.*]] = load i64, ptr [[SRC_ARRAYIDX]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[DST:%.*]], i64 [[IV]]
+; CHECK-NEXT: store i64 [[VAL]], ptr [[DST_ARRAYIDX]], align 4
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: for.inc:
; CHECK-NEXT: [[INC]] = add nuw nsw i64 [[IV]], 1
br i1 %cmp, label %if.then, label %for.inc
if.then:
- %src.arrayidx = getelementptr inbounds i64, i64* %src, i64 %iv
- %val = load i64, i64* %src.arrayidx
- %dst.arrayidx = getelementptr inbounds i64, i64* %dst, i64 %iv
- store i64 %val, i64* %dst.arrayidx
+ %src.arrayidx = getelementptr inbounds i64, ptr %src, i64 %iv
+ %val = load i64, ptr %src.arrayidx
+ %dst.arrayidx = getelementptr inbounds i64, ptr %dst, i64 %iv
+ store i64 %val, ptr %dst.arrayidx
br label %for.inc
for.inc:
ret void
}
-define void @constant_split_loop_bound_and_exit_cond_inc_with_ne(i64* noalias %src, i64* noalias %dst, i64 %n) {
+define void @constant_split_loop_bound_and_exit_cond_inc_with_ne(ptr noalias %src, ptr noalias %dst, i64 %n) {
; CHECK-LABEL: @constant_split_loop_bound_and_exit_cond_inc_with_ne(
; CHECK-NEXT: loop.ph:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i64 [[IV]], 10
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[FOR_INC]]
; CHECK: if.then:
-; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[SRC:%.*]], i64 [[IV]]
-; CHECK-NEXT: [[VAL:%.*]] = load i64, i64* [[SRC_ARRAYIDX]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[DST:%.*]], i64 [[IV]]
-; CHECK-NEXT: store i64 [[VAL]], i64* [[DST_ARRAYIDX]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[SRC:%.*]], i64 [[IV]]
+; CHECK-NEXT: [[VAL:%.*]] = load i64, ptr [[SRC_ARRAYIDX]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[DST:%.*]], i64 [[IV]]
+; CHECK-NEXT: store i64 [[VAL]], ptr [[DST_ARRAYIDX]], align 4
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: for.inc:
; CHECK-NEXT: [[INC]] = add nuw nsw i64 [[IV]], 1
br i1 %cmp, label %if.then, label %for.inc
if.then:
- %src.arrayidx = getelementptr inbounds i64, i64* %src, i64 %iv
- %val = load i64, i64* %src.arrayidx
- %dst.arrayidx = getelementptr inbounds i64, i64* %dst, i64 %iv
- store i64 %val, i64* %dst.arrayidx
+ %src.arrayidx = getelementptr inbounds i64, ptr %src, i64 %iv
+ %val = load i64, ptr %src.arrayidx
+ %dst.arrayidx = getelementptr inbounds i64, ptr %dst, i64 %iv
+ store i64 %val, ptr %dst.arrayidx
br label %for.inc
for.inc:
ret void
}
-define void @varialbe_split_loop_bound_and_exit_cond_dec_with_slt(i64 %a, i64* noalias %src, i64* noalias %dst, i64 %n) {
+define void @varialbe_split_loop_bound_and_exit_cond_dec_with_slt(i64 %a, ptr noalias %src, ptr noalias %dst, i64 %n) {
; CHECK-LABEL: @varialbe_split_loop_bound_and_exit_cond_dec_with_slt(
; CHECK-NEXT: loop.ph:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i64 [[IV]], [[A:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[FOR_DEC]]
; CHECK: if.then:
-; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[SRC:%.*]], i64 [[IV]]
-; CHECK-NEXT: [[VAL:%.*]] = load i64, i64* [[SRC_ARRAYIDX]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[DST:%.*]], i64 [[IV]]
-; CHECK-NEXT: store i64 [[VAL]], i64* [[DST_ARRAYIDX]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[SRC:%.*]], i64 [[IV]]
+; CHECK-NEXT: [[VAL:%.*]] = load i64, ptr [[SRC_ARRAYIDX]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[DST:%.*]], i64 [[IV]]
+; CHECK-NEXT: store i64 [[VAL]], ptr [[DST_ARRAYIDX]], align 4
; CHECK-NEXT: br label [[FOR_DEC]]
; CHECK: for.dec:
; CHECK-NEXT: [[DEC]] = sub nuw nsw i64 [[IV]], 1
br i1 %cmp, label %if.then, label %for.dec
if.then:
- %src.arrayidx = getelementptr inbounds i64, i64* %src, i64 %iv
- %val = load i64, i64* %src.arrayidx
- %dst.arrayidx = getelementptr inbounds i64, i64* %dst, i64 %iv
- store i64 %val, i64* %dst.arrayidx
+ %src.arrayidx = getelementptr inbounds i64, ptr %src, i64 %iv
+ %val = load i64, ptr %src.arrayidx
+ %dst.arrayidx = getelementptr inbounds i64, ptr %dst, i64 %iv
+ store i64 %val, ptr %dst.arrayidx
br label %for.dec
for.dec:
ret void
}
-define void @constant_split_loop_bound_and_exit_cond_dec_with_slt(i64* noalias %src, i64* noalias %dst, i64 %n) {
+define void @constant_split_loop_bound_and_exit_cond_dec_with_slt(ptr noalias %src, ptr noalias %dst, i64 %n) {
; CHECK-LABEL: @constant_split_loop_bound_and_exit_cond_dec_with_slt(
; CHECK-NEXT: loop.ph:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i64 [[IV]], 10
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[FOR_DEC]]
; CHECK: if.then:
-; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[SRC:%.*]], i64 [[IV]]
-; CHECK-NEXT: [[VAL:%.*]] = load i64, i64* [[SRC_ARRAYIDX]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[DST:%.*]], i64 [[IV]]
-; CHECK-NEXT: store i64 [[VAL]], i64* [[DST_ARRAYIDX]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[SRC:%.*]], i64 [[IV]]
+; CHECK-NEXT: [[VAL:%.*]] = load i64, ptr [[SRC_ARRAYIDX]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[DST:%.*]], i64 [[IV]]
+; CHECK-NEXT: store i64 [[VAL]], ptr [[DST_ARRAYIDX]], align 4
; CHECK-NEXT: br label [[FOR_DEC]]
; CHECK: for.dec:
; CHECK-NEXT: [[DEC]] = sub nuw nsw i64 [[IV]], 1
br i1 %cmp, label %if.then, label %for.dec
if.then:
- %src.arrayidx = getelementptr inbounds i64, i64* %src, i64 %iv
- %val = load i64, i64* %src.arrayidx
- %dst.arrayidx = getelementptr inbounds i64, i64* %dst, i64 %iv
- store i64 %val, i64* %dst.arrayidx
+ %src.arrayidx = getelementptr inbounds i64, ptr %src, i64 %iv
+ %val = load i64, ptr %src.arrayidx
+ %dst.arrayidx = getelementptr inbounds i64, ptr %dst, i64 %iv
+ store i64 %val, ptr %dst.arrayidx
br label %for.dec
for.dec:
ret void
}
-define void @variable_split_loop_bound_and_exit_cond_dec_with_sle(i64 %a, i64* noalias %src, i64* noalias %dst, i64 %n) {
+define void @variable_split_loop_bound_and_exit_cond_dec_with_sle(i64 %a, ptr noalias %src, ptr noalias %dst, i64 %n) {
; CHECK-LABEL: @variable_split_loop_bound_and_exit_cond_dec_with_sle(
; CHECK-NEXT: loop.ph:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i64 [[IV]], [[A:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[FOR_DEC]]
; CHECK: if.then:
-; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[SRC:%.*]], i64 [[IV]]
-; CHECK-NEXT: [[VAL:%.*]] = load i64, i64* [[SRC_ARRAYIDX]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[DST:%.*]], i64 [[IV]]
-; CHECK-NEXT: store i64 [[VAL]], i64* [[DST_ARRAYIDX]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[SRC:%.*]], i64 [[IV]]
+; CHECK-NEXT: [[VAL:%.*]] = load i64, ptr [[SRC_ARRAYIDX]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[DST:%.*]], i64 [[IV]]
+; CHECK-NEXT: store i64 [[VAL]], ptr [[DST_ARRAYIDX]], align 4
; CHECK-NEXT: br label [[FOR_DEC]]
; CHECK: for.dec:
; CHECK-NEXT: [[DEC]] = sub nuw nsw i64 [[IV]], 1
br i1 %cmp, label %if.then, label %for.dec
if.then:
- %src.arrayidx = getelementptr inbounds i64, i64* %src, i64 %iv
- %val = load i64, i64* %src.arrayidx
- %dst.arrayidx = getelementptr inbounds i64, i64* %dst, i64 %iv
- store i64 %val, i64* %dst.arrayidx
+ %src.arrayidx = getelementptr inbounds i64, ptr %src, i64 %iv
+ %val = load i64, ptr %src.arrayidx
+ %dst.arrayidx = getelementptr inbounds i64, ptr %dst, i64 %iv
+ store i64 %val, ptr %dst.arrayidx
br label %for.dec
for.dec:
ret void
}
-define void @constant_split_loop_bound_and_exit_cond_dec_with_sle(i64* noalias %src, i64* noalias %dst, i64 %n) {
+define void @constant_split_loop_bound_and_exit_cond_dec_with_sle(ptr noalias %src, ptr noalias %dst, i64 %n) {
; CHECK-LABEL: @constant_split_loop_bound_and_exit_cond_dec_with_sle(
; CHECK-NEXT: loop.ph:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i64 [[IV]], 10
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[FOR_DEC]]
; CHECK: if.then:
-; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[SRC:%.*]], i64 [[IV]]
-; CHECK-NEXT: [[VAL:%.*]] = load i64, i64* [[SRC_ARRAYIDX]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[DST:%.*]], i64 [[IV]]
-; CHECK-NEXT: store i64 [[VAL]], i64* [[DST_ARRAYIDX]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[SRC:%.*]], i64 [[IV]]
+; CHECK-NEXT: [[VAL:%.*]] = load i64, ptr [[SRC_ARRAYIDX]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[DST:%.*]], i64 [[IV]]
+; CHECK-NEXT: store i64 [[VAL]], ptr [[DST_ARRAYIDX]], align 4
; CHECK-NEXT: br label [[FOR_DEC]]
; CHECK: for.dec:
; CHECK-NEXT: [[DEC]] = sub nuw nsw i64 [[IV]], 1
br i1 %cmp, label %if.then, label %for.dec
if.then:
- %src.arrayidx = getelementptr inbounds i64, i64* %src, i64 %iv
- %val = load i64, i64* %src.arrayidx
- %dst.arrayidx = getelementptr inbounds i64, i64* %dst, i64 %iv
- store i64 %val, i64* %dst.arrayidx
+ %src.arrayidx = getelementptr inbounds i64, ptr %src, i64 %iv
+ %val = load i64, ptr %src.arrayidx
+ %dst.arrayidx = getelementptr inbounds i64, ptr %dst, i64 %iv
+ store i64 %val, ptr %dst.arrayidx
br label %for.dec
for.dec:
}
; LoopBoundSplit pass should ignore phi which is not scevable phi.
-define void @constant_split_loop_bound_and_exit_cond_inc_with_sgt_and_is_not_scevable_phi(i64* noalias %src, i64* noalias %dst, i64 %n) {
+define void @constant_split_loop_bound_and_exit_cond_inc_with_sgt_and_is_not_scevable_phi(ptr noalias %src, ptr noalias %dst, i64 %n) {
; CHECK-LABEL: @constant_split_loop_bound_and_exit_cond_inc_with_sgt_and_is_not_scevable_phi(
; CHECK-NEXT: loop.ph:
; CHECK-NEXT: br label [[LOOP_PH_SPLIT:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i64 [[IV]], 10
; CHECK-NEXT: br i1 true, label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[SRC:%.*]], i64 [[IV]]
-; CHECK-NEXT: [[VAL:%.*]] = load i64, i64* [[SRC_ARRAYIDX]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[DST:%.*]], i64 [[IV]]
-; CHECK-NEXT: store i64 [[VAL]], i64* [[DST_ARRAYIDX]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[SRC:%.*]], i64 [[IV]]
+; CHECK-NEXT: [[VAL:%.*]] = load i64, ptr [[SRC_ARRAYIDX]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr [[DST:%.*]], i64 [[IV]]
+; CHECK-NEXT: store i64 [[VAL]], ptr [[DST_ARRAYIDX]], align 4
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: if.else:
; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: if.else.split:
; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: if.then.split:
-; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, i64* [[SRC]], i64 [[IV_SPLIT]]
-; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, i64* [[SRC_ARRAYIDX_SPLIT]], align 4
-; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, i64* [[DST]], i64 [[IV_SPLIT]]
-; CHECK-NEXT: store i64 [[VAL_SPLIT]], i64* [[DST_ARRAYIDX_SPLIT]], align 4
+; CHECK-NEXT: [[SRC_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[SRC]], i64 [[IV_SPLIT]]
+; CHECK-NEXT: [[VAL_SPLIT:%.*]] = load i64, ptr [[SRC_ARRAYIDX_SPLIT]], align 4
+; CHECK-NEXT: [[DST_ARRAYIDX_SPLIT:%.*]] = getelementptr inbounds i64, ptr [[DST]], i64 [[IV_SPLIT]]
+; CHECK-NEXT: store i64 [[VAL_SPLIT]], ptr [[DST_ARRAYIDX_SPLIT]], align 4
; CHECK-NEXT: br label [[FOR_INC_SPLIT]]
; CHECK: for.inc.split:
; CHECK-NEXT: [[INC_SPLIT]] = add nuw nsw i64 [[IV_SPLIT]], 1
br i1 %cmp, label %if.then, label %if.else
if.then:
- %src.arrayidx = getelementptr inbounds i64, i64* %src, i64 %iv
- %val = load i64, i64* %src.arrayidx
- %dst.arrayidx = getelementptr inbounds i64, i64* %dst, i64 %iv
- store i64 %val, i64* %dst.arrayidx
+ %src.arrayidx = getelementptr inbounds i64, ptr %src, i64 %iv
+ %val = load i64, ptr %src.arrayidx
+ %dst.arrayidx = getelementptr inbounds i64, ptr %dst, i64 %iv
+ store i64 %val, ptr %dst.arrayidx
br label %for.inc
if.else: