Identity = isl_map_add_dims(Identity, isl_dim_in, 1);
Identity = isl_map_add_dims(Identity, isl_dim_out, 1);
+ Domain = isl_set_reset_tuple_id(Domain);
+
isl_map *Map =
isl_map_from_domain_and_range(isl_set_copy(Domain), isl_set_copy(Domain));
isl_set_free(Domain);
/// @returns True if __no__ error occurred, false otherwise.
bool buildAliasGroups(AliasAnalysis &AA);
+ //// @brief Drop all constant dimensions from statment schedules.
+ ///
+ /// Schedule dimensions that are constant accross the scop do not carry
+ /// any information, but would cost compile time due to the increased number
+ /// of scheduling dimensions. To not pay this cost, we remove them.
+ void dropConstantScheduleDims();
+
/// @brief Return all alias groups for this SCoP.
const MinMaxVectorVectorTy &getAliasGroups() const {
return MinMaxAliasGroups;
return MaxLD - MinLD + 1;
}
+void Scop::dropConstantScheduleDims() {
+ isl_union_map *FullSchedule = getSchedule();
+
+ if (isl_union_map_n_map(FullSchedule) == 0) {
+ isl_union_map_free(FullSchedule);
+ return;
+ }
+
+ isl_set *ScheduleSpace =
+ isl_set_from_union_set(isl_union_map_range(FullSchedule));
+ isl_map *DropDimMap = isl_set_identity(isl_set_copy(ScheduleSpace));
+
+ int NumDimsDropped = 0;
+ for (unsigned i = 0; i < isl_set_dim(ScheduleSpace, isl_dim_set); i++)
+ if (i % 2 == 0) {
+ isl_val *FixedVal =
+ isl_set_plain_get_val_if_fixed(ScheduleSpace, isl_dim_set, i);
+ if (isl_val_is_int(FixedVal)) {
+ DropDimMap =
+ isl_map_project_out(DropDimMap, isl_dim_out, i - NumDimsDropped, 1);
+ NumDimsDropped++;
+ }
+ isl_val_free(FixedVal);
+ }
+
+ DropDimMap = isl_map_set_tuple_id(
+ DropDimMap, isl_dim_out, isl_map_get_tuple_id(DropDimMap, isl_dim_in));
+ for (auto *S : *this) {
+ isl_map *Schedule = S->getScattering();
+ Schedule = isl_map_apply_range(Schedule, isl_map_copy(DropDimMap));
+ S->setScattering(Schedule);
+ }
+ isl_set_free(ScheduleSpace);
+ isl_map_free(DropDimMap);
+}
+
Scop::Scop(TempScop &tempScop, LoopInfo &LI, ScalarEvolution &ScalarEvolution,
isl_ctx *Context)
: SE(&ScalarEvolution), R(tempScop.getMaxRegion()),
realignParams();
addParameterBounds();
simplifyAssumedContext();
+ dropConstantScheduleDims();
assert(NestLoops.empty() && "NestLoops not empty at top level!");
}
; RUN: opt %loadPolly -polly-allow-nonaffine -polly-dce -polly-ast -analyze < %s | FileCheck %s
;
-; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
+; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1)
;
; void f(int *A) {
; for (int i = 0; i < 1024; i++)
;
; CHECK: Read: { [Stmt_for_cond[i0] -> MemRef_sum[0]] -> MemRef_sum[0] : i0 >= 0 and i0 <= 100 }
; CHECK: Write: { [Stmt_for_cond[i0] -> MemRef_sum[0]] -> MemRef_sum[0] : i0 >= 0 and i0 <= 100 }
-; CHECK: Schedule: { Stmt_for_cond[i0] -> scattering[0, i0, 0]; [Stmt_for_cond[i0] -> MemRef_sum[0]] -> scattering[0, i0, 0] : i0 <= 100 and i0 >= 0 }
+; CHECK: Schedule: { [Stmt_for_cond[i0] -> MemRef_sum[0]] -> scattering[i0] : i0 <= 100 and i0 >= 0; Stmt_for_cond[i0] -> scattering[i0] }
; CHECK: Wrapped Dependences:
; CHECK: RAW dependences:
; CHECK: { [Stmt_for_cond[i0] -> MemRef_sum[0]] -> [Stmt_for_cond[1 + i0] -> MemRef_sum[0]] : i0 >= 0 and i0 <= 99 }
; annotations.
; CHECK: #pragma omp parallel for
-; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
+; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1)
; CHECK-NOT: #pragma omp parallel for
; CHECK: #pragma simd
; CHECK-NOT: #pragma omp parallel for
-; CHECK: for (int c3 = 0; c3 <= 1023; c3 += 1)
-; CHECK: Stmt_loop_body(c1, c3);
+; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
+; CHECK: Stmt_loop_body(c0, c1);
; CHECK: if (n <= 1024 ? 1 : 0)
; CHECK: #pragma omp parallel for
-; CHECK: for (int c1 = 0; c1 < n; c1 += 1)
+; CHECK: for (int c0 = 0; c0 < n; c0 += 1)
; CHECK: #pragma simd
-; CHECK: for (int c3 = 0; c3 < n; c3 += 1)
-; CHECK: Stmt_loop_body(c1, c3);
+; CHECK: for (int c1 = 0; c1 < n; c1 += 1)
+; CHECK: Stmt_loop_body(c0, c1);
ret void
}
-; CHECK: for (int c1 = 0; c1 < n; c1 += 1)
+; CHECK: for (int c0 = 0; c0 < n; c0 += 1)
; CHECK: #pragma simd
; CHECK: #pragma omp parallel for
-; CHECK: for (int c3 = 0; c3 < n; c3 += 1)
-; CHECK: Stmt_loop_body(c1, c3);
+; CHECK: for (int c1 = 0; c1 < n; c1 += 1)
+; CHECK: Stmt_loop_body(c0, c1);
}
; CHECK: #pragma omp parallel for
-; CHECK: for (int c1 = 0; c1 < n; c1 += 1)
-; CHECK: for (int c3 = 0; c3 < n; c3 += 1)
-; CHECK: Stmt_loop_body(c1, c3);
+; CHECK: for (int c0 = 0; c0 < n; c0 += 1)
+; CHECK: for (int c1 = 0; c1 < n; c1 += 1)
+; CHECK: Stmt_loop_body(c0, c1);
ret void
}
-; CHECK: for (int c1 = 0; c1 < n; c1 += 1)
-; CHECK: Stmt_loop_body(c1)
+; CHECK: for (int c0 = 0; c0 < n; c0 += 1)
+; CHECK: Stmt_loop_body(c0)
; CHECK: #pragma simd
; CHECK: #pragma omp parallel for
-; CHECK: for (int c1 = 0; c1 < n; c1 += 1)
-; CHECK: Stmt_loop_body(c1)
+; CHECK: for (int c0 = 0; c0 < n; c0 += 1)
+; CHECK: Stmt_loop_body(c0)
; CHECK-NOT: #pragma simd
; CHECK-NOT: #pragma omp parallel for
-; CHECK: for (int c1 = 0; c1 < n; c1 += 1)
-; CHECK: Stmt_loop_body(c1)
+; CHECK: for (int c0 = 0; c0 < n; c0 += 1)
+; CHECK: Stmt_loop_body(c0)
; }
;
; CHECK: if (1 && (&MemRef_A[1024] <= &MemRef_B[c] || &MemRef_B[c + 1] <= &MemRef_A[0]))
-; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
-; CHECK: Stmt_for_body(c1);
+; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1)
+; CHECK: Stmt_for_body(c0);
; CHECK: else
; CHECK: /* original code */
;
; }
;
; CHECK: if (1 && (&MemRef_A[1024] <= &MemRef_B[c >= 15 ? 5 : c - 10] || &MemRef_B[c <= 15 ? 6 : c - 9] <= &MemRef_A[0]))
-; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
-; CHECK: Stmt_for_body(c1);
+; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1)
+; CHECK: Stmt_for_body(c0);
; CHECK: else
; CHECK: /* original code */
;
;
; CHECK: #pragma simd reduction (+ : sum{{[1,2]}}, sum{{[1,2]}}) reduction (* : prod) reduction (| : or) reduction (& : and)
; CHECK: #pragma known-parallel reduction (+ : sum{{[1,2]}}, sum{{[1,2]}}) reduction (* : prod) reduction (| : or) reduction (& : and)
-; CHECK: for (int c1 = 0; c1 < N; c1 += 1)
-; CHECK: Stmt_for_body(c1);
+; CHECK: for (int c0 = 0; c0 < N; c0 += 1)
+; CHECK: Stmt_for_body(c0);
;
; void f(int N, int *restrict sum1, int *restrict sum2, int *restrict prod,
; int *restrict and, int *restrict or ) {
; Verify that we won't privatize anything in the outer dimension
;
; CHECK: #pragma known-parallel
-; CHECK: for (int c1 = 0; c1 < 2 * n; c1 += 1)
+; CHECK: for (int c0 = 0; c0 < 2 * n; c0 += 1)
; CHECK: #pragma simd reduction
-; CHECK: for (int c3 = 0; c3 <= 1023; c3 += 1)
-; CHECK: Stmt_for_body3(c1, c3);
+; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
+; CHECK: Stmt_for_body3(c0, c1);
;
; void foo(int *A, long n) {
; for (long i = 0; i < 2 * n; i++)
;
; CHECK-NOT:#pragma known-parallel reduction
; CHECK: #pragma known-parallel
-; CHECK: for (int c1 = 0; c1 <= 2047; c1 += 1)
-; CHECK: for (int c3 = 0; c3 <= 1023; c3 += 1)
+; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1)
+; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
; CHECK: #pragma simd reduction
-; CHECK: for (int c5 = 0; c5 <= 511; c5 += 1)
-; CHECK: Stmt_for_body6(c1, c3, c5);
+; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1)
+; CHECK: Stmt_for_body6(c0, c1, c2);
;
; void rmd(int *A) {
; for (long i = 0; i < 2048; i++)
;
; CHECK-NOT:#pragma known-parallel reduction
; CHECK: #pragma known-parallel
-; CHECK: for (int c1 = 0; c1 <= 2047; c1 += 1)
-; CHECK: for (int c3 = 0; c3 <= 1023; c3 += 1)
+; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1)
+; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
; CHECK: #pragma simd reduction
-; CHECK: for (int c5 = 0; c5 <= 511; c5 += 1)
-; CHECK: Stmt_for_body6(c1, c3, c5);
+; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1)
+; CHECK: Stmt_for_body6(c0, c1, c2);
;
; void rmd2(int *A) {
; for (long i = 0; i < 2048; i++)
;
; CHECK-NOT:#pragma known-parallel reduction
; CHECK: #pragma known-parallel
-; CHECK: for (int c1 = 0; c1 <= 2047; c1 += 1)
-; CHECK: for (int c3 = 0; c3 <= 1023; c3 += 1)
+; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1)
+; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
; CHECK: #pragma simd reduction
-; CHECK: for (int c5 = 0; c5 <= 511; c5 += 1)
-; CHECK: Stmt_for_body6(c1, c3, c5);
+; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1)
+; CHECK: Stmt_for_body6(c0, c1, c2);
;
; void rmd3(int *A) {
; for (long i = 0; i < 2048; i++)
;
; CHECK-NOT:#pragma known-parallel reduction
; CHECK: #pragma known-parallel
-; CHECK: for (int c1 = 0; c1 <= 2047; c1 += 1)
-; CHECK: for (int c3 = 0; c3 <= 1023; c3 += 1)
+; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1)
+; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
; CHECK: #pragma simd reduction
-; CHECK: for (int c5 = 0; c5 <= 511; c5 += 1)
-; CHECK: Stmt_for_body6(c1, c3, c5);
+; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1)
+; CHECK: Stmt_for_body6(c0, c1, c2);
;
; void rmd4(int *A) {
; for (long i = 0; i < 2048; i++)
}
; CHECK: if (1)
-; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
-; CHECK: Stmt_for_body(c1);
+; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1)
+; CHECK: Stmt_for_body(c0);
; CHECK: else
; CHECK: { /* original code */ }
; CHECK: if (o >= 1) {
; CHECK: for (int c1 = 0; c1 < n; c1 += 1)
-; CHECK: for (int c3 = 0; c3 < m; c3 += 1)
-; CHECK: Stmt_for_j(c1, c3);
+; CHECK: for (int c2 = 0; c2 < m; c2 += 1)
+; CHECK: Stmt_for_j(c1, c2);
; CHECK: } else
; CHECK: for (int c1 = 0; c1 < n; c1 += 1)
-; CHECK: for (int c3 = 0; c3 < m; c3 += 1)
-; CHECK: Stmt_for_j_1(c1, c3);
+; CHECK: for (int c2 = 0; c2 < m; c2 += 1)
+; CHECK: Stmt_for_j_1(c1, c2);
; CHECK: else
; CHECK: { /* original code */ }
ret void
}
-; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
-; CHECK: Stmt_for_body(c1);
+; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1)
+; CHECK: Stmt_for_body(c0);
; CHECK-VECTOR: #pragma known-parallel
; CHECK-VECTOR: for (int c0 = 0; c0 <= 1023; c0 += 4)
for.end: ; preds = %a
br label %for.cond5
-for.cond5: ; preds = %for.inc17, %for.end
+for.cond5: ; preds = %for.inc07, %for.end
ret void
}
br label %for.body
for.body: ; preds = %for.body, %entry.split
- %j.01 = phi i32 [ 0, %entry.split ], [ %inc3, %for.body ]
+ %j.01 = phi i32 [ 0, %entry.split ], [ %inc1, %for.body ]
%t.02.reload = load float* %t.02.reg2mem
%inc = fadd float %t.02.reload, 1.000000e+00
- %inc3 = add nsw i32 %j.01, 1
- %exitcond = icmp eq i32 %inc3, 5000001
+ %inc1 = add nsw i32 %j.01, 1
+ %exitcond = icmp eq i32 %inc1, 5000001
store float %inc, float* %t.02.reg2mem
br i1 %exitcond, label %for.end, label %for.body
br i1 undef, label %for.body, label %for.cond5.preheader
for.body7: ; preds = %for.body7, %for.cond5.preheader
- %i.128 = phi i64 [ 0, %for.cond5.preheader ], [ %inc17, %for.body7 ]
- %inc17 = add nsw i64 %i.128, 1
+ %i.128 = phi i64 [ 0, %for.cond5.preheader ], [ %inc07, %for.body7 ]
+ %inc07 = add nsw i64 %i.128, 1
store i64 undef, i64* %hi.129.reg2mem
br i1 false, label %for.body7, label %for.end18
; properly forward the value of this expression to the subfunction.
; AST: #pragma omp parallel for
-; AST: for (int c1 = 0; c1 <= 1023; c1 += 1)
-; AST: Stmt_for_j(c1);
+; AST: for (int c0 = 0; c0 <= 1023; c0 += 1)
+; AST: Stmt_for_j(c0);
; IR: @single_parallel_loop.polly.subfn
; AST: #pragma simd
; AST: #pragma omp parallel for
-; AST: for (int c1 = 0; c1 <= 1023; c1 += 1)
-; AST: Stmt_for_i(c1);
+; AST: for (int c0 = 0; c0 <= 1023; c0 += 1)
+; AST: Stmt_for_i(c0);
; IR: getelementptr inbounds { [1024 x double]* }* %polly.par.userContext, i32 0, i32 0
; properly forwarded to the subfunction.
; AST: #pragma omp parallel for
-; AST: for (int c1 = 0; c1 < cols; c1 += 1)
-; AST: Stmt_for_body(c1);
+; AST: for (int c0 = 0; c0 < cols; c0 += 1)
+; AST: Stmt_for_body(c0);
; IR: @foo.polly.subfn
; expression defined outside of the scop.
; AST: #pragma omp parallel for
-; AST: for (int c1 = 0; c1 < cols; c1 += 1)
-; AST: Stmt_for_body(c1);
+; AST: for (int c0 = 0; c0 < cols; c0 += 1)
+; AST: Stmt_for_body(c0);
; IR: @bar.polly.subfn
; AST: #pragma simd
; AST: #pragma omp parallel for
-; AST: for (int c1 = 0; c1 <= 99; c1 += 1)
-; AST: Stmt_for_body(c1);
+; AST: for (int c0 = 0; c0 <= 99; c0 += 1)
+; AST: Stmt_for_body(c0);
; IR-LABEL: polly.start:
; IR-NEXT: %0 = bitcast { float* }* %polly.par.userContext to i8*
; k-loop, are correctly passed to the subfunction.
; AST: #pragma minimal dependence distance: 1
-; AST: for (int c1 = max(0, -n + 1); c1 <= 99; c1 += 1)
+; AST: for (int c0 = max(0, -n + 1); c0 <= 99; c0 += 1)
; AST: #pragma omp parallel for
-; AST: for (int c3 = 0; c3 <= 99; c3 += 1)
+; AST: for (int c1 = 0; c1 <= 99; c1 += 1)
; AST: #pragma minimal dependence distance: 1
-; AST: for (int c5 = 0; c5 < n + c1; c5 += 1)
-; AST: Stmt_for_body6(c1, c3, c5);
+; AST: for (int c2 = 0; c2 < n + c0; c2 += 1)
+; AST: Stmt_for_body6(c0, c1, c2);
; IR: %polly.par.userContext = alloca { i64, i64 }
; IR: %4 = bitcast { i64, i64 }* %polly.par.userContext to i8*
entry:
br label %for.cond
-for.cond: ; preds = %for.inc13, %entry
- %i.0 = phi i64 [ 0, %entry ], [ %inc14, %for.inc13 ]
+for.cond: ; preds = %for.inc03, %entry
+ %i.0 = phi i64 [ 0, %entry ], [ %inc04, %for.inc03 ]
%exitcond1 = icmp ne i64 %i.0, 100
br i1 %exitcond1, label %for.body, label %for.end15
for.body: ; preds = %for.cond
br label %for.cond1
-for.cond1: ; preds = %for.inc10, %for.body
- %j.0 = phi i64 [ 0, %for.body ], [ %inc11, %for.inc10 ]
+for.cond1: ; preds = %for.inc00, %for.body
+ %j.0 = phi i64 [ 0, %for.body ], [ %inc01, %for.inc00 ]
%exitcond = icmp ne i64 %j.0, 100
br i1 %exitcond, label %for.body3, label %for.end12
br label %for.cond4
for.end: ; preds = %for.cond4
- br label %for.inc10
+ br label %for.inc00
-for.inc10: ; preds = %for.end
- %inc11 = add nsw i64 %j.0, 1
+for.inc00: ; preds = %for.end
+ %inc01 = add nsw i64 %j.0, 1
br label %for.cond1
for.end12: ; preds = %for.cond1
- br label %for.inc13
+ br label %for.inc03
-for.inc13: ; preds = %for.end12
- %inc14 = add nsw i64 %i.0, 1
+for.inc03: ; preds = %for.end12
+ %inc04 = add nsw i64 %i.0, 1
br label %for.cond
for.end15: ; preds = %for.cond
br i1 %cmp75, label %for.body, label %end
for.body:
- %i.16 = phi i32 [ %inc14, %for.body ], [ 0, %sw.bb3 ]
+ %i.16 = phi i32 [ %inc04, %for.body ], [ 0, %sw.bb3 ]
%idxprom11 = sext i32 %i.16 to i64
%arrayidx12 = getelementptr inbounds double* %tmp, i64 %idxprom11
store double 1.0, double* %arrayidx12, align 8
- %inc14 = add nsw i32 %i.16, 1
- %cmp7 = icmp slt i32 %inc14, %sendcount
+ %inc04 = add nsw i32 %i.16, 1
+ %cmp7 = icmp slt i32 %inc04, %sendcount
br i1 %cmp7, label %for.body, label %end
end:
; AST: if (symbol >= p_2 + 1) {
; AST-NEXT: #pragma simd
; AST-NEXT: #pragma omp parallel for
-; AST-NEXT: for (int c1 = 0; c1 < p_0 + symbol; c1 += 1)
-; AST-NEXT: Stmt_while_body(c1);
+; AST-NEXT: for (int c0 = 0; c0 < p_0 + symbol; c0 += 1)
+; AST-NEXT: Stmt_while_body(c0);
; AST-NEXT: } else
; AST-NEXT: #pragma simd
; AST-NEXT: #pragma omp parallel for
-; AST-NEXT: for (int c1 = 0; c1 <= p_0 + p_2; c1 += 1)
-; AST-NEXT: Stmt_while_body(c1);
+; AST-NEXT: for (int c0 = 0; c0 <= p_0 + p_2; c0 += 1)
+; AST-NEXT: Stmt_while_body(c0);
; IR: @update_model.polly.subfn
; IR: @update_model.polly.subfn1
br label %for.one
for.one:
- %i.1 = phi i64 [ %dec17, %for.one ], [ %symbol, %entry ]
- %dec17 = add nsw i64 %i.1, -1
+ %i.1 = phi i64 [ %dec07, %for.one ], [ %symbol, %entry ]
+ %dec07 = add nsw i64 %i.1, -1
br i1 undef, label %for.one, label %while.body
while.body:
; AST: #pragma simd
; AST: #pragma omp parallel for
-; AST: for (int c1 = 0; c1 <= 1023; c1 += 1)
-; AST: Stmt_S(c1);
+; AST: for (int c0 = 0; c0 <= 1023; c0 += 1)
+; AST: Stmt_S(c0);
; AST-STRIDE4: #pragma omp parallel for
-; AST-STRIDE4: for (int c1 = 0; c1 <= 1023; c1 += 4)
+; AST-STRIDE4: for (int c0 = 0; c0 <= 1023; c0 += 4)
; AST-STRIDE4: #pragma simd
-; AST-STRIDE4: for (int c2 = c1; c2 <= c1 + 3; c2 += 1)
-; AST-STRIDE4: Stmt_S(c2);
+; AST-STRIDE4: for (int c1 = c0; c1 <= c0 + 3; c1 += 1)
+; AST-STRIDE4: Stmt_S(c1);
; IR-LABEL: single_parallel_loop()
; IR-NEXT: entry
; AST: #pragma simd
; AST: #pragma omp parallel for
-; AST: for (int c1 = 0; c1 <= 1023; c1 += 1)
-; AST: Stmt_S(c1);
+; AST: for (int c0 = 0; c0 <= 1023; c0 += 1)
+; AST: Stmt_S(c0);
; IR: @single_parallel_loop.polly.subfn
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
],
"domain" : "{ Stmt_S[i0] : i0 >= 0 and i0 <= 1023 }",
"name" : "Stmt_S",
- "schedule" : "{ Stmt_S[i0] -> scattering[0, floor(i0/4) * 4, i0] }"
+ "schedule" : "{ Stmt_S[i0] -> scattering[floor(i0/4) * 4, i0] }"
}
]
}
; AST: if (nj >= p_1 + 3) {
; AST: #pragma simd
; AST: #pragma omp parallel for
-; AST: for (int c1 = 0; c1 < p_0 + nj - 1; c1 += 1)
-; AST: Stmt_for_body35(c1);
+; AST: for (int c0 = 0; c0 < p_0 + nj - 1; c0 += 1)
+; AST: Stmt_for_body35(c0);
; AST: } else
; AST: #pragma simd
; AST: #pragma omp parallel for
-; AST: for (int c1 = 0; c1 <= p_0 + p_1; c1 += 1)
-; AST: Stmt_for_body35(c1);
+; AST: for (int c0 = 0; c0 <= p_0 + p_1; c0 += 1)
+; AST: Stmt_for_body35(c0);
; IR: @foo.polly.subfn
; IR: @foo.polly.subfn1
entry:
br label %for.cond
-for.cond: ; preds = %for.inc13, %entry
- %i.0 = phi i64 [ 0, %entry ], [ %inc14, %for.inc13 ]
+for.cond: ; preds = %for.inc03, %entry
+ %i.0 = phi i64 [ 0, %entry ], [ %inc04, %for.inc03 ]
%exitcond2 = icmp ne i64 %i.0, 100
br i1 %exitcond2, label %for.body, label %for.end15
for.body: ; preds = %for.cond
br label %for.cond1
-for.cond1: ; preds = %for.inc10, %for.body
- %j.0 = phi i64 [ 0, %for.body ], [ %inc11, %for.inc10 ]
+for.cond1: ; preds = %for.inc00, %for.body
+ %j.0 = phi i64 [ 0, %for.body ], [ %inc01, %for.inc00 ]
%exitcond1 = icmp ne i64 %j.0, 150
br i1 %exitcond1, label %for.body3, label %for.end12
br label %for.cond4
for.end: ; preds = %for.cond4
- br label %for.inc10
+ br label %for.inc00
-for.inc10: ; preds = %for.end
- %inc11 = add nsw i64 %j.0, 1
+for.inc00: ; preds = %for.end
+ %inc01 = add nsw i64 %j.0, 1
br label %for.cond1
for.end12: ; preds = %for.cond1
- br label %for.inc13
+ br label %for.inc03
-for.inc13: ; preds = %for.end12
- %inc14 = add nsw i64 %i.0, 1
+for.inc03: ; preds = %for.end12
+ %inc04 = add nsw i64 %i.0, 1
br label %for.cond
for.end15: ; preds = %for.cond
entry:
br i1 undef, label %while.cond14.preheader, label %for.body7.single_entry.single_entry
-while.cond14.preheader: ; preds = %for.inc12, %for.body7.single_entry.single_entry, %entry
+while.cond14.preheader: ; preds = %for.inc02, %for.body7.single_entry.single_entry, %entry
ret void
-for.body7.single_entry.single_entry: ; preds = %for.inc12, %entry
+for.body7.single_entry.single_entry: ; preds = %for.inc02, %entry
br i1 undef, label %while.cond14.preheader, label %while.body
while.body: ; preds = %while.body, %for.body7.single_entry.single_entry
%indvar35 = phi i32 [ %0, %while.body ], [ 0, %for.body7.single_entry.single_entry ]
%0 = add i32 %indvar35, 1
%exitcond2 = icmp eq i32 %0, 0
- br i1 %exitcond2, label %for.inc12, label %while.body
+ br i1 %exitcond2, label %for.inc02, label %while.body
-for.inc12: ; preds = %while.body
+for.inc02: ; preds = %while.body
br i1 undef, label %while.cond14.preheader, label %for.body7.single_entry.single_entry
}
declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind
-; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1) {
-; CHECK: if (c1 >= 513) {
-; CHECK: Stmt_5(c1);
+; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1) {
+; CHECK: if (c0 >= 513) {
+; CHECK: Stmt_5(c0);
; CHECK: } else
-; CHECK: Stmt_4(c1);
-; CHECK: Stmt_6(c1);
+; CHECK: Stmt_4(c0);
+; CHECK: Stmt_6(c0);
; CHECK: }
; there is a conditional inside.
; CHECK: #pragma simd
-; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1) {
-; CHECK: if (c1 >= m + 1025) {
-; CHECK: Stmt_if_else(c1);
+; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1) {
+; CHECK: if (c0 >= m + 1025) {
+; CHECK: Stmt_if_else(c0);
; CHECK: } else
-; CHECK: Stmt_if_then(c1);
-; CHECK: Stmt_if_end(c1);
+; CHECK: Stmt_if_then(c0);
+; CHECK: Stmt_if_end(c0);
; CHECK: }
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
for.end: ; preds = %for.cond
br label %for.cond6
-for.cond6: ; preds = %for.inc32, %for.end
- %indvar = phi i64 [ %indvar.next, %for.inc32 ], [ 0, %for.end ]
+for.cond6: ; preds = %for.inc12, %for.end
+ %indvar = phi i64 [ %indvar.next, %for.inc12 ], [ 0, %for.end ]
%arrayidx15 = getelementptr [1024 x i32]* @A, i64 0, i64 %indvar
%i.1 = trunc i64 %indvar to i32
%cmp8 = icmp slt i32 %i.1, 1024
br label %if.end31
if.end31: ; preds = %if.end30
- br label %for.inc32
+ br label %for.inc12
-for.inc32: ; preds = %if.end31
+for.inc12: ; preds = %if.end31
%indvar.next = add i64 %indvar, 1
br label %for.cond6
declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind
-; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1) {
-; CHECK: if (c1 >= 513) {
-; CHECK: Stmt_4(c1);
-; CHECK: } else if (c1 <= 511) {
-; CHECK: Stmt_4(c1);
+; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1) {
+; CHECK: if (c0 >= 513) {
+; CHECK: Stmt_4(c0);
+; CHECK: } else if (c0 <= 511) {
+; CHECK: Stmt_4(c0);
; CHECK: } else
; CHECK: Stmt_5(512);
-; CHECK: Stmt_6(c1);
+; CHECK: Stmt_6(c0);
; CHECK: }
declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind
-; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1) {
-; CHECK: if (c1 <= 20) {
-; CHECK: Stmt_7(c1);
-; CHECK: } else if (c1 <= 512)
-; CHECK: Stmt_6(c1);
-; CHECK: Stmt_9(c1);
+; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1) {
+; CHECK: if (c0 <= 20) {
+; CHECK: Stmt_7(c0);
+; CHECK: } else if (c0 <= 512)
+; CHECK: Stmt_6(c0);
+; CHECK: Stmt_9(c0);
; CHECK: }
; LOOPS: Printing analysis 'Natural Loop Information' for function 'loop_with_condition':
declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind
-; CHECK: for (int c1 = 0; c1 <= 1018; c1 += 1)
-; CHECK: Stmt_for_body(c1);
+; CHECK: for (int c0 = 0; c0 <= 1018; c0 += 1)
+; CHECK: Stmt_for_body(c0);
declare i32 @rand()
-; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
-; CHECK: Stmt_for_body(c1);
+; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1)
+; CHECK: Stmt_for_body(c0);
declare i32 @fprintf(%struct._IO_FILE*, i8*, ...)
-; CHECK: for (int c1 = 0; c1 <= 2147483646; c1 += 1)
-; CHECK: Stmt_do_body(c1);
+; CHECK: for (int c0 = 0; c0 <= 2147483646; c0 += 1)
+; CHECK: Stmt_do_body(c0);
ret i32 %retval.0
}
-; CHECK: for (int c1 = 0; c1 <= 9223372036854775806; c1 += 1)
-; CHECK: Stmt_do_body(c1);
+; CHECK: for (int c0 = 0; c0 <= 9223372036854775806; c0 += 1)
+; CHECK: Stmt_do_body(c0);
declare i32 @fprintf(%struct._IO_FILE*, i8*, ...)
-; CHECK: for (int c1 = 0; c1 <= 19; c1 += 1)
-; CHECK: Stmt_do_cond(c1);
+; CHECK: for (int c0 = 0; c0 <= 19; c0 += 1)
+; CHECK: Stmt_do_cond(c0);
for.end: ; preds = %for.cond
br label %for.cond5
-for.cond5: ; preds = %for.inc17, %for.end
- %indvar = phi i64 [ %indvar.next, %for.inc17 ], [ 0, %for.end ] ; <i64> [#uses=3]
+for.cond5: ; preds = %for.inc07, %for.end
+ %indvar = phi i64 [ %indvar.next, %for.inc07 ], [ 0, %for.end ] ; <i64> [#uses=3]
%arrayidx13 = getelementptr [1024 x i32]* %A, i64 0, i64 %indvar ; <i32*> [#uses=1]
%i.1 = trunc i64 %indvar to i32 ; <i32> [#uses=1]
%cmp7 = icmp slt i32 %i.1, 1024 ; <i1> [#uses=1]
br label %return
if.end: ; preds = %for.body9
- br label %for.inc17
+ br label %for.inc07
-for.inc17: ; preds = %if.end
+for.inc07: ; preds = %if.end
%indvar.next = add i64 %indvar, 1 ; <i64> [#uses=1]
br label %for.cond5
declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind
-; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
-; CHECK: Stmt_for_body(c1);
+; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1)
+; CHECK: Stmt_for_body(c0);
ret i32 %retval.0
}
-; CHECK: for (int c1 = 0; c1 <= 2147483646; c1 += 1)
-; CHECK: Stmt_for_body(c1);
+; CHECK: for (int c0 = 0; c0 <= 2147483646; c0 += 1)
+; CHECK: Stmt_for_body(c0);
ret i32 %retval.0
}
-; CHECK: for (int c1 = 0; c1 <= 9223372036854775806; c1 += 1)
-; CHECK: Stmt_for_body(c1);
+; CHECK: for (int c0 = 0; c0 <= 9223372036854775806; c0 += 1)
+; CHECK: Stmt_for_body(c0);
declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind
-; CHECK: for (int c1 = 0; c1 < n; c1 += 1)
-; CHECK: Stmt_bb2(c1);
+; CHECK: for (int c0 = 0; c0 < n; c0 += 1)
+; CHECK: Stmt_bb2(c0);
br i1 true, label %bb2, label %bb3
bb2:
- %ind1 = phi i32 [0, %bb1], [ %inc1, %bb2]
- %inc1 = add i32 %ind1, 1
+ %ind1 = phi i32 [0, %bb1], [ %inc0, %bb2]
+ %inc0 = add i32 %ind1, 1
%cond1 = icmp eq i32 %ind1, 32
br i1 %cond1, label %bb4, label %bb2
br label %bb2
bb2:
- %ind1 = phi i32 [0, %bb1], [ %inc1, %bb2]
- %inc1 = add i32 %ind1, 1
+ %ind1 = phi i32 [0, %bb1], [ %inc0, %bb2]
+ %inc0 = add i32 %ind1, 1
%cond1 = icmp eq i32 %ind1, 32
br i1 %cond1, label %bb4, label %bb2
for.cond45.preheader: ; preds = %if.end
br i1 undef, label %for.body47, label %for.end198
-for.body47: ; preds = %for.inc196, %for.cond45.preheader
- br i1 undef, label %for.body53.lr.ph, label %for.inc196
+for.body47: ; preds = %for.inc096, %for.cond45.preheader
+ br i1 undef, label %for.body53.lr.ph, label %for.inc096
for.body53.lr.ph: ; preds = %for.body47
br label %for.body53
store float %add189, float* %arrayidx191, align 4
%add193 = add nsw i32 %i.013, 2
%cmp52 = icmp slt i32 %add193, %ido
- br i1 %cmp52, label %for.body53, label %for.inc196
+ br i1 %cmp52, label %for.body53, label %for.inc096
-for.inc196: ; preds = %for.body53, %for.body47
+for.inc096: ; preds = %for.body53, %for.body47
br i1 undef, label %for.body47, label %for.end198
-for.end198: ; preds = %for.inc196, %for.cond45.preheader
+for.end198: ; preds = %for.inc096, %for.cond45.preheader
br i1 false, label %for.end256, label %L105
L105: ; preds = %for.end198, %if.end
bb.nph31.split.us:
br label %bb.nph.us
-for.inc16.us: ; preds = %for.body6.us
+for.inc06.us: ; preds = %for.body6.us
store i32 %mul.us, i32* %arrayidx.us
%indvar.next = add i64 %indvar, 1 ; <i64> [#uses=2]
%exitcond32 = icmp eq i64 %indvar.next, 100 ; <i1> [#uses=1]
%mul.us = mul i32 %arrayidx10.tmp.0.us, %0 ; <i32> [#uses=2]
%inc.us = add nsw i32 %0, 1 ; <i32> [#uses=2]
%exitcond = icmp eq i32 %inc.us, 200 ; <i1> [#uses=1]
- br i1 %exitcond, label %for.inc16.us, label %for.body6.us
+ br i1 %exitcond, label %for.inc06.us, label %for.body6.us
-bb.nph.us: ; preds = %bb.nph31.split.us, %for.inc16.us
- %indvar = phi i64 [ %indvar.next, %for.inc16.us ], [ 0, %bb.nph31.split.us ] ; <i64> [#uses=3]
+bb.nph.us: ; preds = %bb.nph31.split.us, %for.inc06.us
+ %indvar = phi i64 [ %indvar.next, %for.inc06.us ], [ 0, %bb.nph31.split.us ] ; <i64> [#uses=3]
%arrayidx.us = getelementptr [100 x i32]* @A, i64 0, i64 %indvar ; <i32*> [#uses=2]
%i.027.us = trunc i64 %indvar to i32 ; <i32> [#uses=2]
store i32 %i.027.us, i32* %arrayidx.us
br label %for.body6.us
-for.end19: ; preds = %for.inc16.us
+for.end19: ; preds = %for.inc06.us
%idxprom21 = sext i32 %z to i64 ; <i64> [#uses=1]
%arrayidx22 = getelementptr inbounds [100 x i32]* @A, i64 0, i64 %idxprom21 ; <i32*> [#uses=1]
%tmp23 = load i32* %arrayidx22 ; <i32> [#uses=1]
; CHECK: if (1)
; CHECK: {
-; CHECK: for (int c1 = 0; c1 <= -Scalar0.val.loadoutside + 99; c1 += 1)
-; CHECK: Stmt_for_1(c1);
+; CHECK: for (int c0 = 0; c0 <= -Scalar0.val.loadoutside + 99; c0 += 1)
+; CHECK: Stmt_for_1(c0);
; CHECK: if (Scalar0.val.loadoutside >= 100)
; CHECK: Stmt_for_1(0);
; CHECK: }
ret void
}
-; CHECK: for (int c1 = 0; c1 <= n; c1 += 1)
-; CHECK: Stmt_loop_body(c1)
+; CHECK: for (int c0 = 0; c0 <= n; c0 += 1)
+; CHECK: Stmt_loop_body(c0)
; CODEGEN: polly.start:
; CODEGEN: br label %polly.loop_if
ret void
}
-; CHECK: for (int c1 = 0; c1 < n; c1 += 1)
-; CHECK: Stmt_loop_body(c1)
+; CHECK: for (int c0 = 0; c0 < n; c0 += 1)
+; CHECK: Stmt_loop_body(c0)
; CODEGEN: polly.start:
; CODEGEN: br label %polly.loop_if
; CHECK: Domain :=
; CHECK: [N, M] -> { Stmt_bb1[i0, i1] : i0 >= 0 and i0 <= 2 + 4N + 7M and i1 >= 0 and i1 <= 1 + 5N and N >= 0 };
; CHECK: Scattering :=
-; CHECK: [N, M] -> { Stmt_bb1[i0, i1] -> scattering[0, i0, 0, i1, 0] };
+; CHECK: [N, M] -> { Stmt_bb1[i0, i1] -> scattering[i0, i1] };
; CHECK: MustWriteAccess := [Reduction Type: NONE]
; CHECK: [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[i0 + 128i1] };
; CHECK: }
; CHECK: Domain :=
; CHECK: [N, M] -> { Stmt_bb1[i0, i1] : i0 >= 0 and i0 <= 2 + 4N + 7M and i1 >= 0 and i1 <= 1 + 5N - i0 and i0 <= 1 + 5N };
; CHECK: Scattering :=
-; CHECK: [N, M] -> { Stmt_bb1[i0, i1] -> scattering[0, i0, 0, i1, 0] };
+; CHECK: [N, M] -> { Stmt_bb1[i0, i1] -> scattering[i0, i1] };
; CHECK: MustWriteAccess := [Reduction Type: NONE]
; CHECK: [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[129i0 + 128i1] };
; CHECK: }
; CHECK: Domain :=
; CHECK: [N, M] -> { Stmt_bb1[i0, i1] : i0 >= 0 and i0 <= 2 + 4N + 7M and i1 >= 0 and i1 <= 10 + 5N - 6M - 4i0 and 4i0 <= 10 + 5N - 6M };
; CHECK: Scattering :=
-; CHECK: [N, M] -> { Stmt_bb1[i0, i1] -> scattering[0, i0, 0, i1, 0] };
+; CHECK: [N, M] -> { Stmt_bb1[i0, i1] -> scattering[i0, i1] };
; CHECK: MustWriteAccess := [Reduction Type: NONE]
; CHECK: [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[-1152 + 768M + 897i0 + 128i1] };
; CHECK: }
; CHECK: Domain :=
; CHECK: [n] -> { Stmt_bb_nph[] : n >= 2 };
; CHECK: Scattering :=
-; CHECK: [n] -> { Stmt_bb_nph[] -> scattering[0, 0, 0] };
+; CHECK: [n] -> { Stmt_bb_nph[] -> scattering[0, 0] };
; CHECK: ReadAccess :=
; CHECK: [n] -> { Stmt_bb_nph[] -> MemRef_a[0] };
; CHECK: MustWriteAccess :=
; CHECK: Domain :=
; CHECK: [n] -> { Stmt_bb[i0] : i0 >= 0 and i0 <= -2 + n and n >= 2 };
; CHECK: Scattering :=
-; CHECK: [n] -> { Stmt_bb[i0] -> scattering[1, i0, 0] };
+; CHECK: [n] -> { Stmt_bb[i0] -> scattering[1, i0] };
; CHECK: ReadAccess :=
; CHECK: [n] -> { Stmt_bb[i0] -> MemRef__reg2mem[0] };
; CHECK: ReadAccess :=
; CHECK: Domain :=
; CHECK: [n] -> { Stmt_for_i[i0] : i0 >= 0 and i0 <= -1 + n };
; CHECK: Scattering :=
-; CHECK: [n] -> { Stmt_for_i[i0] -> scattering[0, i0, 0] };
+; CHECK: [n] -> { Stmt_for_i[i0] -> scattering[i0] };
; CHECK: MustWriteAccess :=
; CHECK: [n] -> { Stmt_for_i[i0] -> MemRef_A[i0, i0] };
; CHECK: Domain :=
; CHECK: [m, p] -> { Stmt_for_j[i0, i1] : i0 >= 0 and i0 <= 99 and i1 >= 0 and i1 <= -1 + m };
; CHECK: Scattering :=
-; CHECK: [m, p] -> { Stmt_for_j[i0, i1] -> scattering[0, i0, 0, i1, 0] };
+; CHECK: [m, p] -> { Stmt_for_j[i0, i1] -> scattering[i0, i1] };
; CHECK: MustWriteAccess := [Reduction Type: NONE]
; CHECK: [m, p] -> { Stmt_for_j[i0, i1] -> MemRef_A[p + i0, i1] };
; CHECK: }
; CHECK: Domain :=
; CHECK: [m] -> { Stmt_for_j[i0, i1] : i0 >= 0 and i0 <= 99 and i1 >= 0 and i1 <= 149 };
; CHECK: Scattering :=
-; CHECK: [m] -> { Stmt_for_j[i0, i1] -> scattering[0, i0, 0, i1, 0] };
+; CHECK: [m] -> { Stmt_for_j[i0, i1] -> scattering[i0, i1] };
; CHECK: MustWriteAccess := [Reduction Type: NONE]
; CHECK: [m] -> { Stmt_for_j[i0, i1] -> MemRef_A[i0, i1] };
; CHECK: Domain :=
; CHECK: [m, o] -> { Stmt_for_k[i0, i1, i2] : i0 >= 0 and i0 <= 99 and i1 >= 0 and i1 <= 149 and i2 >= 0 and i2 <= 199 };
; CHECK: Scattering :=
-; CHECK: [m, o] -> { Stmt_for_k[i0, i1, i2] -> scattering[0, i0, 0, i1, 0, i2, 0] };
+; CHECK: [m, o] -> { Stmt_for_k[i0, i1, i2] -> scattering[i0, i1, i2] };
; CHECK: MustWriteAccess := [Reduction Type: NONE]
; CHECK: [m, o] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[i0, i1, i2] };
; CHECK: Domain
; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] : i0 >= 0 and i0 <= -4 + n and i1 >= 0 and i1 <= -5 + m and i2 >= 0 and i2 <= -8 + o };
; CHECK: Scattering
-; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] -> scattering[0, i0, 0, i1, 0, i2, 0] };
+; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] -> scattering[i0, i1, i2] };
; CHECK: MustWriteAccess
; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[3 + i0, i1, 7 + i2] };
; CHECK: Domain
; CHECK: [n, m, o, p, q, r] -> { Stmt_for_k[i0, i1, i2] : i0 >= 0 and i0 <= -1 + n and i1 >= 0 and i1 <= -1 + m and i2 >= 0 and i2 <= -1 + o };
; CHECK: Scattering
-; CHECK: [n, m, o, p, q, r] -> { Stmt_for_k[i0, i1, i2] -> scattering[0, i0, 0, i1, 0, i2, 0] };
+; CHECK: [n, m, o, p, q, r] -> { Stmt_for_k[i0, i1, i2] -> scattering[i0, i1, i2] };
; CHECK: MustWriteAccess
; CHECK: [n, m, o, p, q, r] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[p + i0, q + i1, r + i2] };
; CHECK: Domain
; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] : i0 >= 0 and i0 <= -4 + n and i1 >= 0 and i1 <= -5 + m and i2 >= 0 and i2 <= -8 + o };
; CHECK: Scattering
-; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] -> scattering[0, i0, 0, i1, 0, i2, 0] };
+; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] -> scattering[i0, i1, i2] };
; CHECK: MustWriteAccess
; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[3 + i0, i1, 7 + i2] };
; CHECK: Domain
; CHECK: [n, m] -> { Stmt_for_j[i0, i1] : i0 >= 0 and i0 <= -1 + n and i1 >= 0 and i1 <= -1 + m };
; CHECK: Scattering
-; CHECK: [n, m] -> { Stmt_for_j[i0, i1] -> scattering[0, i0, 0, i1, 0] };
+; CHECK: [n, m] -> { Stmt_for_j[i0, i1] -> scattering[i0, i1] };
; CHECK: MustWriteAccess
; CHECK: [n, m] -> { Stmt_for_j[i0, i1] -> MemRef_A[i0, i1] };
; CHECK: Domain
; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] : i0 >= 0 and i0 <= -1 + n and i1 >= 0 and i1 <= -1 + m and i2 >= 0 and i2 <= -1 + o };
; CHECK: Scattering
-; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] -> scattering[0, i0, 0, i1, 0, i2, 0] };
+; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] -> scattering[i0, i1, i2] };
; CHECK: WriteAccess
; CHECK: [n, m, o] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[i0, i1, i2] };
; CHECK: Domain
; CHECK: [n, m, o, p_3, p_4] -> { Stmt_for_k[i0, i1, i2] : i0 >= 0 and i0 <= -1 + n and i1 >= 0 and i1 <= -1 + m and i2 >= 0 and i2 <= -1 + o };
; CHECK: Scattering
-; CHECK: [n, m, o, p_3, p_4] -> { Stmt_for_k[i0, i1, i2] -> scattering[0, i0, 0, i1, 0, i2, 0] };
+; CHECK: [n, m, o, p_3, p_4] -> { Stmt_for_k[i0, i1, i2] -> scattering[i0, i1, i2] };
; CHECK: WriteAccess
; CHECK: [n, m, o, p_3, p_4] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[i0, i1, i2] };
; CHECK: Domain
; CHECK: [n, o, m] -> { Stmt_for_j[i0, i1, i2] : i0 >= 0 and i0 <= -1 + n and i1 >= 0 and i1 <= -1 + o and i2 >= 0 and i2 <= -1 + m };
; CHECK: Scattering
-; CHECK: [n, o, m] -> { Stmt_for_j[i0, i1, i2] -> scattering[0, i0, 0, i1, 0, i2, 0] };
+; CHECK: [n, o, m] -> { Stmt_for_j[i0, i1, i2] -> scattering[i0, i1, i2] };
; CHECK: WriteAccess
; CHECK: [n, o, m] -> { Stmt_for_j[i0, i1, i2] -> MemRef_A[i0, i2, i1] };
; CHECK: Domain
; CHECK: [n] -> { Stmt_for_body[i0] : i0 >= 0 and i0 <= -1 + n };
; CHECK: Scattering
-; CHECK: [n] -> { Stmt_for_body[i0] -> scattering[0, i0, 0] };
+; CHECK: [n] -> { Stmt_for_body[i0] -> scattering[i0] };
; CHECK: ReadAccess
; CHECK: [n] -> { Stmt_for_body[i0] -> MemRef_INDEX[i0] };
; CHECK: WriteAccess
; CHECK: Domain :=
; CHECK: [N] -> { Stmt_S1[i0] : i0 >= 0 and i0 <= -1 + N };
; CHECK: Scattering :=
-; CHECK: [N] -> { Stmt_S1[i0] -> scattering[0, i0, 0] };
+; CHECK: [N] -> { Stmt_S1[i0] -> scattering[i0, 0] };
; CHECK: ReadAccess :=
; CHECK: [N] -> { Stmt_S1[i0] -> MemRef_a[i0] };
; CHECK: MustWriteAccess :=
; CHECK: Domain :=
; CHECK: [N] -> { Stmt_S2[i0] : i0 >= 0 and i0 <= -1 + N };
; CHECK: Scattering :=
-; CHECK: [N] -> { Stmt_S2[i0] -> scattering[0, i0, 1] };
+; CHECK: [N] -> { Stmt_S2[i0] -> scattering[i0, 1] };
; CHECK: ReadAccess :=
; CHECK: [N] -> { Stmt_S2[i0] -> MemRef_val[] };
; CHECK: MustWriteAccess :=
; CHECK: Domain :=
; CHECK: [N] -> { Stmt_bb[i0] : i0 >= 0 and i0 <= -1 + N };
; CHECK: Scattering :=
-; CHECK: [N] -> { Stmt_bb[i0] -> scattering[0, i0, 0] };
+; CHECK: [N] -> { Stmt_bb[i0] -> scattering[i0] };
; CHECK: MustWriteAccess := [Reduction Type: NONE]
; CHECK: [N] -> { Stmt_bb[i0] -> MemRef_a[i0] };