a99a982440
Add test coverage for remark when runtime checks are not profitable with threshold provided. Also make sure that X86 remark tests actually passes an X86 triple, which is needed for the threshold remark. Also clean up the tests a bit.
459 lines
20 KiB
LLVM
459 lines
20 KiB
LLVM
; RUN: opt -passes='function(loop-vectorize,require<access-info>)' -disable-output -pass-remarks-analysis=loop-vectorize < %s 2>&1 | FileCheck %s
|
|
; RUN: opt < %s -passes='function(require<access-info>,loop-vectorize)' -disable-output -pass-remarks-output=%t.yaml
|
|
; RUN: cat %t.yaml | FileCheck -check-prefix=YAML %s
|
|
|
|
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
|
|
|
|
; // Loop has an array element B[i] (%arrayidx in IR) being used as index to
|
|
; // another array (A), and since the value of B[i] is unknown,
|
|
; // the bound for array A is unknown.
|
|
; void test_unknown_bounds(int n, int* A, int* B) {
|
|
; for(int i = 0; i < n ; ++i)
|
|
; A[i] = A[B[i]] + 1;
|
|
; }
|
|
|
|
; CHECK: remark: source.c:4:16: loop not vectorized: cannot identify array bounds
|
|
|
|
define void @test_unknown_bounds(i64 %n, ptr nocapture %A, ptr nocapture readonly %B) !dbg !13 {
|
|
entry:
|
|
%cmp10 = icmp sgt i64 %n, 0
|
|
br i1 %cmp10, label %loop, label %exit
|
|
|
|
loop:
|
|
%iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
|
|
%gep.B = getelementptr inbounds i32, ptr %B, i64 %iv
|
|
%0 = load i32, ptr %gep.B, align 4
|
|
%idxprom1 = sext i32 %0 to i64, !dbg !35
|
|
%arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %idxprom1, !dbg !35
|
|
%1 = load i32, ptr %arrayidx2, align 4, !dbg !35
|
|
%add = add nsw i32 %1, 1
|
|
%gep.A = getelementptr inbounds i32, ptr %A, i64 %iv
|
|
store i32 %add, ptr %gep.A, align 4
|
|
%iv.next = add nuw nsw i64 %iv, 1
|
|
%ec = icmp eq i64 %iv.next, %n
|
|
br i1 %ec, label %exit, label %loop, !dbg !28
|
|
|
|
exit:
|
|
ret void
|
|
}
|
|
|
|
; // a) Dependence::NoDep
|
|
; // Loop containing only reads (here of the array A) does not hinder vectorization
|
|
; void test_nodep(int n, int* A, int* B) {
|
|
; for(int i = 1; i < n ; ++i) {
|
|
; B[i] = A[i-1] + A[i+2];
|
|
; }
|
|
; }
|
|
|
|
; CHECK-NOT: remark: source.c:{{0-9]+}}:{{[0-9]+}}:
|
|
|
|
define void @test_nodep(i64 %n, ptr nocapture readonly %A, ptr nocapture %B) !dbg !44 {
|
|
entry:
|
|
%cmp12 = icmp sgt i64 %n, 1
|
|
br i1 %cmp12, label %loop, label %exit
|
|
|
|
loop:
|
|
%iv = phi i64 [ 1, %entry ], [ %iv.next, %loop ]
|
|
%0 = add nsw i64 %iv, -1
|
|
%arrayidx = getelementptr inbounds i32, ptr %A, i64 %0, !dbg !61
|
|
%1 = load i32, ptr %arrayidx, align 4, !dbg !61
|
|
%2 = add nuw nsw i64 %iv, 2
|
|
%arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %2, !dbg !63
|
|
%3 = load i32, ptr %arrayidx2, align 4, !dbg !63
|
|
%add3 = add nsw i32 %3, %1
|
|
%arrayidx5 = getelementptr inbounds i32, ptr %B, i64 %iv
|
|
store i32 %add3, ptr %arrayidx5, align 4
|
|
%iv.next = add nuw nsw i64 %iv, 1
|
|
%ec = icmp eq i64 %iv.next, %n
|
|
br i1 %ec, label %exit, label %loop
|
|
|
|
exit:
|
|
ret void
|
|
}
|
|
|
|
|
|
; // b) Dependence::Forward
|
|
; // Loop gets vectorized since it contains only a forward
|
|
; // dependency between A[i-2] and A[i]
|
|
; void test_forward(int n, int* A, int* B) {
|
|
; for(int i=1; i < n; ++i) {
|
|
; A[i] = 10;
|
|
; B[i] = A[i-2];
|
|
; }
|
|
; }
|
|
|
|
; CHECK-NOT: remark: source.c:{{0-9]+}}:{{[0-9]+}}:
|
|
define dso_local void @test_forward(i64 %n, ptr nocapture %A, ptr nocapture %B) !dbg !70 {
|
|
entry:
|
|
%cmp11 = icmp sgt i64 %n, 1
|
|
br i1 %cmp11, label %loop, label %exit, !dbg !81
|
|
|
|
loop:
|
|
%iv = phi i64 [ 1, %entry ], [ %iv.next, %loop ]
|
|
%arrayidx = getelementptr inbounds i32, ptr %A, i64 %iv, !dbg !83
|
|
store i32 10, ptr %arrayidx, align 4
|
|
%0 = add nsw i64 %iv, -2
|
|
%arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %0, !dbg !87
|
|
%1 = load i32, ptr %arrayidx2, align 4, !dbg !87
|
|
%gep.B = getelementptr inbounds i32, ptr %B, i64 %iv, !dbg !88
|
|
store i32 %1, ptr %gep.B, align 4, !dbg !89
|
|
%iv.next = add nuw nsw i64 %iv, 1
|
|
%ec = icmp eq i64 %iv.next, %n
|
|
br i1 %ec, label %exit, label %loop, !dbg !81
|
|
|
|
exit:
|
|
ret void
|
|
}
|
|
|
|
|
|
; // c) Dependence::BackwardVectorizable
|
|
; // Loop gets vectorized since it contains a backward dependency
|
|
; // between A[i] and A[i-4], but the dependency distance (4) is
|
|
; // greater than the minimum possible VF (2 in this case)
|
|
; void test_backwardVectorizable(int n, int* A) {
|
|
; for(int i=4; i < n; ++i) {
|
|
; A[i] = A[i-4] + 1;
|
|
; }
|
|
; }
|
|
|
|
; CHECK-NOT: remark: source.c:{{0-9]+}}:{{[0-9]+}}:
|
|
|
|
define dso_local void @test_backwardVectorizable(i64 %n, ptr nocapture %A) !dbg !93 {
|
|
entry:
|
|
%cmp8 = icmp sgt i64 %n, 4
|
|
br i1 %cmp8, label %loop, label %exit
|
|
|
|
loop:
|
|
%iv = phi i64 [ 4, %entry ], [ %iv.next, %loop ]
|
|
%0 = add nsw i64 %iv, -4, !dbg !106
|
|
%arrayidx = getelementptr inbounds i32, ptr %A, i64 %0, !dbg !108
|
|
%1 = load i32, ptr %arrayidx, align 4, !dbg !108
|
|
%add = add nsw i32 %1, 1
|
|
%arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %iv, !dbg !110
|
|
store i32 %add, ptr %arrayidx2, align 4, !dbg !111
|
|
%iv.next = add nuw nsw i64 %iv, 1
|
|
%ec = icmp eq i64 %iv.next, %n
|
|
br i1 %ec, label %exit, label %loop
|
|
|
|
exit:
|
|
ret void
|
|
}
|
|
|
|
; // d) Dependence::Backward
|
|
; // Loop does not get vectorized since it contains a backward
|
|
; // dependency between A[i] and A[i+3].
|
|
; void test_backward_dep(int n, int *A) {
|
|
; for (int i = 1; i <= n - 3; i += 3) {
|
|
; A[i] = A[i-1];
|
|
; A[i+1] = A[i+3];
|
|
; }
|
|
; }
|
|
|
|
; CHECK: remark: source.c:48:14: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
|
|
; CHECK-NEXT: Backward loop carried data dependence. Memory location is the same as accessed at source.c:47:5
|
|
|
|
define void @test_backward_dep(i64 %n, ptr nocapture %A) {
|
|
entry:
|
|
%cmp.not19 = icmp slt i64 %n, 4
|
|
br i1 %cmp.not19, label %exit, label %loop.preheader
|
|
|
|
loop.preheader: ; preds = %entry
|
|
%sub = add nsw i64 %n, -3
|
|
br label %loop
|
|
|
|
loop: ; preds = %loop.preheader, %loop
|
|
%iv = phi i64 [ 1, %loop.preheader ], [ %iv.next, %loop ]
|
|
%0 = add nsw i64 %iv, -1
|
|
%arrayidx = getelementptr inbounds i32, ptr %A, i64 %0
|
|
%1 = load i32, ptr %arrayidx, align 8
|
|
%arrayidx3 = getelementptr inbounds i32, ptr %A, i64 %iv, !dbg !157
|
|
store i32 %1, ptr %arrayidx3, align 8
|
|
%iv.next = add nuw nsw i64 %iv, 3
|
|
%arrayidx5 = getelementptr inbounds i32, ptr %A, i64 %iv.next, !dbg !160
|
|
%2 = load i32, ptr %arrayidx5, align 8, !dbg !160
|
|
%3 = add nuw nsw i64 %iv, 1
|
|
%arrayidx8 = getelementptr inbounds i32, ptr %A, i64 %3
|
|
store i32 %2, ptr %arrayidx8, align 8
|
|
%cmp.not = icmp ugt i64 %iv.next, %n
|
|
br i1 %cmp.not, label %exit, label %loop
|
|
|
|
exit:
|
|
ret void
|
|
}
|
|
|
|
; // e) Dependence::ForwardButPreventsForwarding
|
|
; // Loop does not get vectorized despite only having a forward
|
|
; // dependency between A[i] and A[i-3].
|
|
; // This is because the store-to-load forwarding distance (here 3)
|
|
; // needs to be a multiple of vector factor otherwise the
|
|
; // store (A[5:6] in i=5) and load (A[4:5],A[6:7] in i=7,9) are unaligned.
|
|
; void test_forwardButPreventsForwarding_dep(int n, int* A, int* B) {
|
|
; for(int i=3; i < n; ++i) {
|
|
; A[i] = 10;
|
|
; B[i] = A[i-3];
|
|
; }
|
|
; }
|
|
|
|
; CHECK: remark: source.c:61:12: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
|
|
; CHECK-NEXT: Forward loop carried data dependence that prevents store-to-load forwarding. Memory location is the same as accessed at source.c:60:5
|
|
|
|
define void @test_forwardButPreventsForwarding_dep(i64 %n, ptr nocapture %A, ptr nocapture %B) !dbg !166 {
|
|
entry:
|
|
%cmp11 = icmp sgt i64 %n, 3
|
|
br i1 %cmp11, label %loop, label %exit
|
|
|
|
loop:
|
|
%iv = phi i64 [ 3, %entry ], [ %iv.next, %loop ]
|
|
%arrayidx = getelementptr inbounds i32, ptr %A, i64 %iv, !dbg !179
|
|
store i32 10, ptr %arrayidx, align 4
|
|
%0 = add nsw i64 %iv, -3
|
|
%arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %0, !dbg !183
|
|
%1 = load i32, ptr %arrayidx2, align 4, !dbg !183
|
|
%gep.B = getelementptr inbounds i32, ptr %B, i64 %iv
|
|
store i32 %1, ptr %gep.B, align 4
|
|
%iv.next = add nuw nsw i64 %iv, 1
|
|
%ec = icmp eq i64 %iv.next, %n
|
|
br i1 %ec, label %exit, label %loop
|
|
|
|
exit:
|
|
ret void
|
|
}
|
|
|
|
; // f) Dependence::BackwardVectorizableButPreventsForwarding
|
|
; // Loop does not get vectorized despite having a backward
|
|
; // but vectorizable dependency between A[i] and A[i-15].
|
|
; //
|
|
; // This is because the store-to-load forwarding distance (here 15)
|
|
; // needs to be a multiple of vector factor otherwise
|
|
; // store (A[16:17] in i=16) and load (A[15:16], A[17:18] in i=30,32) are unaligned.
|
|
; void test_backwardVectorizableButPreventsForwarding(int n, int* A) {
|
|
; for(int i=15; i < n; ++i) {
|
|
; A[i] = A[i-2] + A[i-15];
|
|
; }
|
|
; }
|
|
|
|
; CHECK: remark: source.c:74:5: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
|
|
; CHECK: Backward loop carried data dependence that prevents store-to-load forwarding. Memory location is the same as accessed at source.c:74:21
|
|
|
|
define void @test_backwardVectorizableButPreventsForwarding(i64 %n, ptr nocapture %A) !dbg !189 {
|
|
entry:
|
|
%cmp13 = icmp sgt i64 %n, 15
|
|
br i1 %cmp13, label %loop, label %exit
|
|
|
|
loop:
|
|
%iv = phi i64 [ 15, %entry ], [ %iv.next, %loop ]
|
|
%0 = add nsw i64 %iv, -2
|
|
%arrayidx = getelementptr inbounds i32, ptr %A, i64 %0
|
|
%1 = load i32, ptr %arrayidx, align 4
|
|
%2 = add nsw i64 %iv, -15
|
|
%arrayidx3 = getelementptr inbounds i32, ptr %A, i64 %2, !dbg !207
|
|
%3 = load i32, ptr %arrayidx3, align 4
|
|
%add = add nsw i32 %3, %1
|
|
%arrayidx5 = getelementptr inbounds i32, ptr %A, i64 %iv, !dbg !209
|
|
store i32 %add, ptr %arrayidx5, align 4, !dbg !209
|
|
%iv.next = add nuw nsw i64 %iv, 1
|
|
%ec = icmp eq i64 %iv.next, %n
|
|
br i1 %ec, label %exit, label %loop
|
|
|
|
exit:
|
|
ret void
|
|
}
|
|
|
|
; // g) Dependence::Unknown
|
|
; // Different stride lengths
|
|
; void test_unknown_dep(int n, int* A) {
|
|
; for(int i=0; i < n; ++i) {
|
|
; A[(i+1)*4] = 10;
|
|
; A[i] = 100;
|
|
; }
|
|
; }
|
|
|
|
; CHECK: remark: source.c:83:7: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
|
|
; CHECK: Unknown data dependence. Memory location is the same as accessed at source.c:82:7
|
|
|
|
define void @test_unknown_dep(i64 %n, ptr nocapture %A) !dbg !214 {
|
|
entry:
|
|
%cmp8 = icmp sgt i64 %n, 0
|
|
br i1 %cmp8, label %loop, label %exit
|
|
|
|
loop:
|
|
%iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
|
|
%iv.next = add nuw nsw i64 %iv, 1
|
|
%0 = shl nsw i64 %iv.next, 2
|
|
%arrayidx = getelementptr inbounds i32, ptr %A, i64 %0, !dbg !229
|
|
store i32 10, ptr %arrayidx, align 4
|
|
%arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %iv, !dbg !231
|
|
store i32 100, ptr %arrayidx2, align 4, !dbg !231
|
|
%ec = icmp eq i64 %iv.next, %n
|
|
br i1 %ec, label %exit, label %loop
|
|
|
|
exit:
|
|
ret void
|
|
}
|
|
|
|
; YAML: --- !Analysis
|
|
; YAML-NEXT: Pass: loop-vectorize
|
|
; YAML-NEXT: Name: CantIdentifyArrayBounds
|
|
; YAML-NEXT: DebugLoc: { File: source.c, Line: 4, Column: 16 }
|
|
; YAML-NEXT: Function: test_unknown_bounds
|
|
; YAML-NEXT: Args:
|
|
; YAML-NEXT: - String: 'loop not vectorized: '
|
|
; YAML-NEXT: - String: cannot identify array bounds
|
|
; YAML-NEXT: ...
|
|
; YAML-NEXT: --- !Missed
|
|
; YAML-NEXT: Pass: loop-vectorize
|
|
; YAML-NEXT: Name: MissedDetails
|
|
; YAML-NEXT: DebugLoc: { File: source.c, Line: 3, Column: 5 }
|
|
; YAML-NEXT: Function: test_unknown_bounds
|
|
; YAML-NEXT: Args:
|
|
; YAML-NEXT: - String: loop not vectorized
|
|
; YAML-NEXT: ...
|
|
; YAML: --- !Analysis
|
|
; YAML-NEXT: Pass: loop-vectorize
|
|
; YAML-NEXT: Name: UnsafeDep
|
|
; YAML-NEXT: DebugLoc: { File: source.c, Line: 48, Column: 14 }
|
|
; YAML-NEXT: Function: test_backward_dep
|
|
; YAML-NEXT: Args:
|
|
; YAML-NEXT: - String: 'loop not vectorized: '
|
|
; YAML-NEXT: - String: 'unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop'
|
|
; YAML-NEXT: - String: "\nBackward loop carried data dependence."
|
|
; YAML-NEXT: - String: ' Memory location is the same as accessed at '
|
|
; YAML-NEXT: - Location: 'source.c:47:5'
|
|
; YAML-NEXT: DebugLoc: { File: source.c, Line: 47, Column: 5 }
|
|
; YAML-NEXT: ...
|
|
; YAML-NEXT: --- !Missed
|
|
; YAML-NEXT: Pass: loop-vectorize
|
|
; YAML-NEXT: Name: MissedDetails
|
|
; YAML-NEXT: Function: test_backward_dep
|
|
; YAML-NEXT: Args:
|
|
; YAML-NEXT: - String: loop not vectorized
|
|
; YAML-NEXT: ...
|
|
; YAML-NEXT: --- !Analysis
|
|
; YAML-NEXT: Pass: loop-vectorize
|
|
; YAML-NEXT: Name: UnsafeDep
|
|
; YAML-NEXT: DebugLoc: { File: source.c, Line: 61, Column: 12 }
|
|
; YAML-NEXT: Function: test_forwardButPreventsForwarding_dep
|
|
; YAML-NEXT: Args:
|
|
; YAML-NEXT: - String: 'loop not vectorized: '
|
|
; YAML-NEXT: - String: 'unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop'
|
|
; YAML-NEXT: - String: "\nForward loop carried data dependence that prevents store-to-load forwarding."
|
|
; YAML-NEXT: - String: ' Memory location is the same as accessed at '
|
|
; YAML-NEXT: - Location: 'source.c:60:5'
|
|
; YAML-NEXT: DebugLoc: { File: source.c, Line: 60, Column: 5 }
|
|
; YAML-NEXT: ...
|
|
; YAML-NEXT: --- !Missed
|
|
; YAML-NEXT: Pass: loop-vectorize
|
|
; YAML-NEXT: Name: MissedDetails
|
|
; YAML-NEXT: Function: test_forwardButPreventsForwarding_dep
|
|
; YAML-NEXT: Args:
|
|
; YAML-NEXT: - String: loop not vectorized
|
|
; YAML-NEXT: ...
|
|
; YAML-NEXT: --- !Analysis
|
|
; YAML-NEXT: Pass: loop-vectorize
|
|
; YAML-NEXT: Name: UnsafeDep
|
|
; YAML-NEXT: DebugLoc: { File: source.c, Line: 74, Column: 5 }
|
|
; YAML-NEXT: Function: test_backwardVectorizableButPreventsForwarding
|
|
; YAML-NEXT: Args:
|
|
; YAML-NEXT: - String: 'loop not vectorized: '
|
|
; YAML-NEXT: - String: 'unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop'
|
|
; YAML-NEXT: - String: "\nBackward loop carried data dependence that prevents store-to-load forwarding."
|
|
; YAML-NEXT: - String: ' Memory location is the same as accessed at '
|
|
; YAML-NEXT: - Location: 'source.c:74:21'
|
|
; YAML-NEXT: DebugLoc: { File: source.c, Line: 74, Column: 21 }
|
|
; YAML-NEXT: ...
|
|
; YAML-NEXT: --- !Missed
|
|
; YAML-NEXT: Pass: loop-vectorize
|
|
; YAML-NEXT: Name: MissedDetails
|
|
; YAML-NEXT: Function: test_backwardVectorizableButPreventsForwarding
|
|
; YAML-NEXT: Args:
|
|
; YAML-NEXT: - String: loop not vectorized
|
|
; YAML-NEXT: ...
|
|
; YAML-NEXT: --- !Analysis
|
|
; YAML-NEXT: Pass: loop-vectorize
|
|
; YAML-NEXT: Name: UnsafeDep
|
|
; YAML-NEXT: DebugLoc: { File: source.c, Line: 83, Column: 7 }
|
|
; YAML-NEXT: Function: test_unknown_dep
|
|
; YAML-NEXT: Args:
|
|
; YAML-NEXT: - String: 'loop not vectorized: '
|
|
; YAML-NEXT: - String: 'unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop'
|
|
; YAML-NEXT: - String: "\nUnknown data dependence."
|
|
; YAML-NEXT: - String: ' Memory location is the same as accessed at '
|
|
; YAML-NEXT: - Location: 'source.c:82:7'
|
|
; YAML-NEXT: DebugLoc: { File: source.c, Line: 82, Column: 7 }
|
|
; YAML-NEXT: ...
|
|
; YAML-NEXT: --- !Missed
|
|
; YAML-NEXT: Pass: loop-vectorize
|
|
; YAML-NEXT: Name: MissedDetails
|
|
; YAML-NEXT: Function: test_unknown_dep
|
|
; YAML-NEXT: Args:
|
|
; YAML-NEXT: - String: loop not vectorized
|
|
; YAML-NEXT: ...
|
|
|
|
|
|
!llvm.dbg.cu = !{!0}
|
|
!llvm.module.flags = !{!4}
|
|
|
|
!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14.0.0 (https://github.com/llvm/llvm-project.git 54f0f826c5c7d0ff16c230b259cb6aad33e18d97)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
|
|
!1 = !DIFile(filename: "source.c", directory: "")
|
|
!2 = !{}
|
|
!4 = !{i32 2, !"Debug Info Version", i32 3}
|
|
!13 = distinct !DISubprogram(name: "test_unknown_bounds", scope: !1, file: !1, line: 2, type: !45, scopeLine: 2, unit: !0, retainedNodes: !2)
|
|
!23 = distinct !DILexicalBlock(scope: !13, file: !1, line: 3, column: 5)
|
|
!27 = distinct !DILexicalBlock(scope: !23, file: !1, line: 3, column: 5)
|
|
!28 = !DILocation(line: 3, column: 5, scope: !23)
|
|
!35 = !DILocation(line: 4, column: 16, scope: !27)
|
|
!44 = distinct !DISubprogram(name: "test_nodep", scope: !1, file: !1, line: 14, type: !45, scopeLine: 14, unit: !0, retainedNodes: !2)
|
|
!45 = !DISubroutineType(types: !46)
|
|
!46 = !{null, !18, !16, !16}
|
|
!16 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !17, size: 64)
|
|
!17 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
|
|
!18 = !DIBasicType(name: "int", size: 64, encoding: DW_ATE_signed)
|
|
!52 = distinct !DILexicalBlock(scope: !44, file: !1, line: 15, column: 3)
|
|
!56 = distinct !DILexicalBlock(scope: !52, file: !1, line: 15, column: 3)
|
|
!60 = distinct !DILexicalBlock(scope: !56, file: !1, line: 15, column: 31)
|
|
!61 = !DILocation(line: 16, column: 12, scope: !60)
|
|
!63 = !DILocation(line: 16, column: 21, scope: !60)
|
|
!70 = distinct !DISubprogram(name: "test_forward", scope: !1, file: !1, line: 24, type: !45, scopeLine: 24, unit: !0, retainedNodes: !2)
|
|
!77 = distinct !DILexicalBlock(scope: !70, file: !1, line: 25, column: 3)
|
|
!80 = distinct !DILexicalBlock(scope: !77, file: !1, line: 25, column: 3)
|
|
!81 = !DILocation(line: 25, column: 3, scope: !77)
|
|
!83 = !DILocation(line: 26, column: 5, scope: !84)
|
|
!84 = distinct !DILexicalBlock(scope: !80, file: !1, line: 25, column: 28)
|
|
!87 = !DILocation(line: 27, column: 12, scope: !84)
|
|
!88 = !DILocation(line: 27, column: 5, scope: !84)
|
|
!89 = !DILocation(line: 27, column: 10, scope: !84)
|
|
!93 = distinct !DISubprogram(name: "test_backwardVectorizable", scope: !1, file: !1, line: 36, type: !95, scopeLine: 36, unit: !0, retainedNodes: !2)
|
|
!95 = !DISubroutineType(types: !96)
|
|
!96 = !{null, !18, !16}
|
|
!99 = distinct !DILexicalBlock(scope: !93, file: !1, line: 37, column: 3)
|
|
!103 = distinct !DILexicalBlock(scope: !99, file: !1, line: 37, column: 3)
|
|
!106 = !DILocation(line: 38, column: 15, scope: !107)
|
|
!107 = distinct !DILexicalBlock(scope: !103, file: !1, line: 37, column: 28)
|
|
!108 = !DILocation(line: 38, column: 12, scope: !107)
|
|
!110 = !DILocation(line: 38, column: 5, scope: !107)
|
|
!111 = !DILocation(line: 38, column: 10, scope: !107)
|
|
!136 = distinct !DISubprogram(name: "test_backward_dep", scope: !1, file: !1, line: 45, type: !95, scopeLine: 45, unit: !0, retainedNodes: !2)
|
|
!145 = distinct !DILexicalBlock(scope: !136, file: !1, line: 46, column: 3)
|
|
!149 = distinct !DILexicalBlock(scope: !145, file: !1, line: 46, column: 3)
|
|
!153 = distinct !DILexicalBlock(scope: !149, file: !1, line: 46, column: 39)
|
|
!157 = !DILocation(line: 47, column: 5, scope: !153)
|
|
!160 = !DILocation(line: 48, column: 14, scope: !153)
|
|
!166 = distinct !DISubprogram(name: "test_forwardButPreventsForwarding_dep", scope: !1, file: !1, line: 58, type: !45, scopeLine: 58, unit: !0, retainedNodes: !2)
|
|
!172 = distinct !DILexicalBlock(scope: !166, file: !1, line: 59, column: 3)
|
|
!176 = distinct !DILexicalBlock(scope: !172, file: !1, line: 59, column: 3)
|
|
!179 = !DILocation(line: 60, column: 5, scope: !180)
|
|
!180 = distinct !DILexicalBlock(scope: !176, file: !1, line: 59, column: 28)
|
|
!183 = !DILocation(line: 61, column: 12, scope: !180)
|
|
!189 = distinct !DISubprogram(name: "test_backwardVectorizableButPreventsForwarding", scope: !1, file: !1, line: 72, type: !95, scopeLine: 72, unit: !0, retainedNodes: !2)
|
|
!196 = distinct !DILexicalBlock(scope: !189, file: !1, line: 73, column: 3)
|
|
!200 = distinct !DILexicalBlock(scope: !196, file: !1, line: 73, column: 3)
|
|
!204 = distinct !DILexicalBlock(scope: !200, file: !1, line: 73, column: 29)
|
|
!207 = !DILocation(line: 74, column: 21, scope: !204)
|
|
!209 = !DILocation(line: 74, column: 5, scope: !204)
|
|
!214 = distinct !DISubprogram(name: "test_unknown_dep", scope: !1, file: !1, line: 80, type: !95, scopeLine: 80, unit: !0, retainedNodes: !2)
|
|
!219 = distinct !DILexicalBlock(scope: !214, file: !1, line: 81, column: 3)
|
|
!223 = distinct !DILexicalBlock(scope: !219, file: !1, line: 81, column: 3)
|
|
!227 = distinct !DILexicalBlock(scope: !223, file: !1, line: 81, column: 28)
|
|
!229 = !DILocation(line: 82, column: 7, scope: !227)
|
|
!231 = !DILocation(line: 83, column: 7, scope: !227)
|