459 lines · plain
1; RUN: opt -passes='function(loop-vectorize,require<access-info>)' -disable-output -pass-remarks-analysis=loop-vectorize < %s 2>&1 | FileCheck %s2; RUN: opt < %s -passes='function(require<access-info>,loop-vectorize)' -o /dev/null -pass-remarks-output=%t.yaml3; RUN: cat %t.yaml | FileCheck -check-prefix=YAML %s4 5target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"6 7; // Loop has an array element B[i] (%arrayidx in IR) being used as index to8; // another array (A), and since the value of B[i] is unknown,9; // the bound for array A is unknown.10; void test_unknown_bounds(int n, int* A, int* B) {11; for(int i = 0; i < n ; ++i)12; A[i] = A[B[i]] + 1;13; }14 15; CHECK: remark: source.c:4:16: loop not vectorized: cannot identify array bounds16 17define void @test_unknown_bounds(i64 %n, ptr nocapture %A, ptr nocapture readonly %B) !dbg !13 {18entry:19 %cmp10 = icmp sgt i64 %n, 020 br i1 %cmp10, label %for.body, label %for.cond.cleanup21 22for.body: ; preds = %entry, %for.body23 %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]24 %arrayidx = getelementptr inbounds i32, ptr %B, i64 %indvars.iv25 %0 = load i32, ptr %arrayidx, align 426 %idxprom1 = sext i32 %0 to i64, !dbg !3527 %arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %idxprom1, !dbg !3528 %1 = load i32, ptr %arrayidx2, align 4, !dbg !3529 %add = add nsw i32 %1, 130 %arrayidx4 = getelementptr inbounds i32, ptr %A, i64 %indvars.iv31 store i32 %add, ptr %arrayidx4, align 432 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 133 %exitcond.not = icmp eq i64 %indvars.iv.next, %n34 br i1 %exitcond.not, label %for.cond.cleanup, label %for.body, !dbg !2835 36for.cond.cleanup: ; preds = %for.body, %entry37 ret void38}39 40; // a) Dependence::NoDep41; // Loop containing only reads (here of the array A) does not hinder vectorization42; void test_nodep(int n, int* A, int* B) {43; for(int i = 1; i < n ; ++i) {44; B[i] = A[i-1] + A[i+2];45; }46; }47 48; CHECK-NOT: remark: source.c:{{0-9]+}}:{{[0-9]+}}:49 50define void @test_nodep(i64 %n, ptr nocapture readonly %A, ptr nocapture %B) !dbg !44 {51entry:52 %cmp12 = icmp sgt i64 %n, 153 br i1 %cmp12, label %for.body, label %for.cond.cleanup54 55for.body: ; preds = %entry, %for.body56 %indvars.iv = phi i64 [ 1, %entry ], [ %indvars.iv.next, %for.body ]57 %0 = add nsw i64 %indvars.iv, -158 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %0, !dbg !6159 %1 = load i32, ptr %arrayidx, align 4, !dbg !6160 %2 = add nuw nsw i64 %indvars.iv, 261 %arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %2, !dbg !6362 %3 = load i32, ptr %arrayidx2, align 4, !dbg !6363 %add3 = add nsw i32 %3, %164 %arrayidx5 = getelementptr inbounds i32, ptr %B, i64 %indvars.iv65 store i32 %add3, ptr %arrayidx5, align 466 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 167 %exitcond.not = icmp eq i64 %indvars.iv.next, %n68 br i1 %exitcond.not, label %for.cond.cleanup, label %for.body69 70for.cond.cleanup: ; preds = %for.body, %entry71 ret void72}73 74 75; // b) Dependence::Forward76; // Loop gets vectorized since it contains only a forward77; // dependency between A[i-2] and A[i]78; void test_forward(int n, int* A, int* B) {79; for(int i=1; i < n; ++i) {80; A[i] = 10;81; B[i] = A[i-2];82; }83; }84 85; CHECK-NOT: remark: source.c:{{0-9]+}}:{{[0-9]+}}:86define dso_local void @test_forward(i64 %n, ptr nocapture %A, ptr nocapture %B) !dbg !70 {87entry:88 %cmp11 = icmp sgt i64 %n, 189 br i1 %cmp11, label %for.body, label %for.cond.cleanup, !dbg !8190 91for.body: ; preds = %entry, %for.body92 %indvars.iv = phi i64 [ 1, %entry ], [ %indvars.iv.next, %for.body ]93 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv, !dbg !8394 store i32 10, ptr %arrayidx, align 495 %0 = add nsw i64 %indvars.iv, -296 %arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %0, !dbg !8797 %1 = load i32, ptr %arrayidx2, align 4, !dbg !8798 %arrayidx4 = getelementptr inbounds i32, ptr %B, i64 %indvars.iv, !dbg !8899 store i32 %1, ptr %arrayidx4, align 4, !dbg !89100 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1101 %exitcond.not = icmp eq i64 %indvars.iv.next, %n102 br i1 %exitcond.not, label %for.cond.cleanup, label %for.body, !dbg !81103 104 for.cond.cleanup: ; preds = %for.body, %entry105 ret void106}107 108 109; // c) Dependence::BackwardVectorizable110; // Loop gets vectorized since it contains a backward dependency111; // between A[i] and A[i-4], but the dependency distance (4) is112; // greater than the minimum possible VF (2 in this case)113; void test_backwardVectorizable(int n, int* A) {114; for(int i=4; i < n; ++i) {115; A[i] = A[i-4] + 1;116; }117; }118 119; CHECK-NOT: remark: source.c:{{0-9]+}}:{{[0-9]+}}:120 121define dso_local void @test_backwardVectorizable(i64 %n, ptr nocapture %A) !dbg !93 {122entry:123 %cmp8 = icmp sgt i64 %n, 4124 br i1 %cmp8, label %for.body, label %for.cond.cleanup125 126for.body: ; preds = %entry, %for.body127 %indvars.iv = phi i64 [ 4, %entry ], [ %indvars.iv.next, %for.body ]128 %0 = add nsw i64 %indvars.iv, -4, !dbg !106129 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %0, !dbg !108130 %1 = load i32, ptr %arrayidx, align 4, !dbg !108131 %add = add nsw i32 %1, 1132 %arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %indvars.iv, !dbg !110133 store i32 %add, ptr %arrayidx2, align 4, !dbg !111134 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1135 %exitcond.not = icmp eq i64 %indvars.iv.next, %n136 br i1 %exitcond.not, label %for.cond.cleanup, label %for.body137 138 for.cond.cleanup: ; preds = %for.body, %entry139 ret void140}141 142; // d) Dependence::Backward143; // Loop does not get vectorized since it contains a backward144; // dependency between A[i] and A[i+3].145; void test_backward_dep(int n, int *A) {146; for (int i = 1; i <= n - 3; i += 3) {147; A[i] = A[i-1];148; A[i+1] = A[i+3];149; }150; }151 152; 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 loop153; CHECK-NEXT: Backward loop carried data dependence. Memory location is the same as accessed at source.c:47:5154 155define void @test_backward_dep(i64 %n, ptr nocapture %A) {156entry:157 %cmp.not19 = icmp slt i64 %n, 4158 br i1 %cmp.not19, label %for.cond.cleanup, label %for.body.preheader159 160for.body.preheader: ; preds = %entry161 %sub = add nsw i64 %n, -3162 br label %for.body163 164for.body: ; preds = %for.body.preheader, %for.body165 %indvars.iv = phi i64 [ 1, %for.body.preheader ], [ %indvars.iv.next, %for.body ]166 %0 = add nsw i64 %indvars.iv, -1167 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %0168 %1 = load i32, ptr %arrayidx, align 8169 %arrayidx3 = getelementptr inbounds i32, ptr %A, i64 %indvars.iv, !dbg !157170 store i32 %1, ptr %arrayidx3, align 8171 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 3172 %arrayidx5 = getelementptr inbounds i32, ptr %A, i64 %indvars.iv.next, !dbg !160173 %2 = load i32, ptr %arrayidx5, align 8, !dbg !160174 %3 = add nuw nsw i64 %indvars.iv, 1175 %arrayidx8 = getelementptr inbounds i32, ptr %A, i64 %3176 store i32 %2, ptr %arrayidx8, align 8177 %cmp.not = icmp ugt i64 %indvars.iv.next, %n178 br i1 %cmp.not, label %for.cond.cleanup, label %for.body179 180 for.cond.cleanup: ; preds = %for.body, %entry181 ret void182}183 184; // e) Dependence::ForwardButPreventsForwarding185; // Loop does not get vectorized despite only having a forward186; // dependency between A[i] and A[i-3].187; // This is because the store-to-load forwarding distance (here 3)188; // needs to be a multiple of vector factor otherwise the189; // store (A[5:6] in i=5) and load (A[4:5],A[6:7] in i=7,9) are unaligned.190; void test_forwardButPreventsForwarding_dep(int n, int* A, int* B) {191; for(int i=3; i < n; ++i) {192; A[i] = 10;193; B[i] = A[i-3];194; }195; }196 197; 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 loop198; CHECK-NEXT: Forward loop carried data dependence that prevents store-to-load forwarding. Memory location is the same as accessed at source.c:60:5199 200define void @test_forwardButPreventsForwarding_dep(i64 %n, ptr nocapture %A, ptr nocapture %B) !dbg !166 {201entry:202 %cmp11 = icmp sgt i64 %n, 3203 br i1 %cmp11, label %for.body, label %for.cond.cleanup204 205for.body: ; preds = %entry, %for.body206 %indvars.iv = phi i64 [ 3, %entry ], [ %indvars.iv.next, %for.body ]207 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv, !dbg !179208 store i32 10, ptr %arrayidx, align 4209 %0 = add nsw i64 %indvars.iv, -3210 %arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %0, !dbg !183211 %1 = load i32, ptr %arrayidx2, align 4, !dbg !183212 %arrayidx4 = getelementptr inbounds i32, ptr %B, i64 %indvars.iv213 store i32 %1, ptr %arrayidx4, align 4214 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1215 %exitcond.not = icmp eq i64 %indvars.iv.next, %n216 br i1 %exitcond.not, label %for.cond.cleanup, label %for.body217 218 for.cond.cleanup: ; preds = %for.body, %entry219 ret void220}221 222; // f) Dependence::BackwardVectorizableButPreventsForwarding223; // Loop does not get vectorized despite having a backward224; // but vectorizable dependency between A[i] and A[i-15].225; //226; // This is because the store-to-load forwarding distance (here 15)227; // needs to be a multiple of vector factor otherwise228; // store (A[16:17] in i=16) and load (A[15:16], A[17:18] in i=30,32) are unaligned.229; void test_backwardVectorizableButPreventsForwarding(int n, int* A) {230; for(int i=15; i < n; ++i) {231; A[i] = A[i-2] + A[i-15];232; }233; }234 235; 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 loop236; CHECK: Backward loop carried data dependence that prevents store-to-load forwarding. Memory location is the same as accessed at source.c:74:21237 238define void @test_backwardVectorizableButPreventsForwarding(i64 %n, ptr nocapture %A) !dbg !189 {239entry:240 %cmp13 = icmp sgt i64 %n, 15241 br i1 %cmp13, label %for.body, label %for.cond.cleanup242 243for.body: ; preds = %entry, %for.body244 %indvars.iv = phi i64 [ 15, %entry ], [ %indvars.iv.next, %for.body ]245 %0 = add nsw i64 %indvars.iv, -2246 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %0247 %1 = load i32, ptr %arrayidx, align 4248 %2 = add nsw i64 %indvars.iv, -15249 %arrayidx3 = getelementptr inbounds i32, ptr %A, i64 %2, !dbg !207250 %3 = load i32, ptr %arrayidx3, align 4251 %add = add nsw i32 %3, %1252 %arrayidx5 = getelementptr inbounds i32, ptr %A, i64 %indvars.iv, !dbg !209253 store i32 %add, ptr %arrayidx5, align 4, !dbg !209254 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1255 %exitcond.not = icmp eq i64 %indvars.iv.next, %n256 br i1 %exitcond.not, label %for.cond.cleanup, label %for.body257 258 for.cond.cleanup: ; preds = %for.body, %entry259 ret void260}261 262; // g) Dependence::Unknown263; // Different stride lengths264; void test_unknown_dep(int n, int* A) {265; for(int i=0; i < n; ++i) {266; A[(i+1)*4] = 10;267; A[i] = 100;268; }269; }270 271; 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 loop272; CHECK: Unknown data dependence. Memory location is the same as accessed at source.c:82:7273 274define void @test_unknown_dep(i64 %n, ptr nocapture %A) !dbg !214 {275entry:276 %cmp8 = icmp sgt i64 %n, 0277 br i1 %cmp8, label %for.body, label %for.cond.cleanup278 279for.body: ; preds = %entry, %for.body280 %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]281 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1282 %0 = shl nsw i64 %indvars.iv.next, 2283 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %0, !dbg !229284 store i32 10, ptr %arrayidx, align 4285 %arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %indvars.iv, !dbg !231286 store i32 100, ptr %arrayidx2, align 4, !dbg !231287 %exitcond.not = icmp eq i64 %indvars.iv.next, %n288 br i1 %exitcond.not, label %for.cond.cleanup, label %for.body289 290 for.cond.cleanup: ; preds = %for.body, %entry291 ret void292}293 294; YAML: --- !Analysis295; YAML-NEXT: Pass: loop-vectorize296; YAML-NEXT: Name: CantIdentifyArrayBounds297; YAML-NEXT: DebugLoc: { File: source.c, Line: 4, Column: 16 }298; YAML-NEXT: Function: test_unknown_bounds299; YAML-NEXT: Args:300; YAML-NEXT: - String: 'loop not vectorized: '301; YAML-NEXT: - String: cannot identify array bounds302; YAML-NEXT: ...303; YAML-NEXT: --- !Missed304; YAML-NEXT: Pass: loop-vectorize305; YAML-NEXT: Name: MissedDetails306; YAML-NEXT: DebugLoc: { File: source.c, Line: 3, Column: 5 }307; YAML-NEXT: Function: test_unknown_bounds308; YAML-NEXT: Args:309; YAML-NEXT: - String: loop not vectorized310; YAML-NEXT: ...311; YAML: --- !Analysis312; YAML-NEXT: Pass: loop-vectorize313; YAML-NEXT: Name: UnsafeDep314; YAML-NEXT: DebugLoc: { File: source.c, Line: 48, Column: 14 }315; YAML-NEXT: Function: test_backward_dep316; YAML-NEXT: Args:317; YAML-NEXT: - String: 'loop not vectorized: '318; 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'319; YAML-NEXT: - String: "\nBackward loop carried data dependence."320; YAML-NEXT: - String: ' Memory location is the same as accessed at '321; YAML-NEXT: - Location: 'source.c:47:5'322; YAML-NEXT: DebugLoc: { File: source.c, Line: 47, Column: 5 }323; YAML-NEXT: ...324; YAML-NEXT: --- !Missed325; YAML-NEXT: Pass: loop-vectorize326; YAML-NEXT: Name: MissedDetails327; YAML-NEXT: Function: test_backward_dep328; YAML-NEXT: Args:329; YAML-NEXT: - String: loop not vectorized330; YAML-NEXT: ...331; YAML-NEXT: --- !Analysis332; YAML-NEXT: Pass: loop-vectorize333; YAML-NEXT: Name: UnsafeDep334; YAML-NEXT: DebugLoc: { File: source.c, Line: 61, Column: 12 }335; YAML-NEXT: Function: test_forwardButPreventsForwarding_dep336; YAML-NEXT: Args:337; YAML-NEXT: - String: 'loop not vectorized: '338; 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'339; YAML-NEXT: - String: "\nForward loop carried data dependence that prevents store-to-load forwarding."340; YAML-NEXT: - String: ' Memory location is the same as accessed at '341; YAML-NEXT: - Location: 'source.c:60:5'342; YAML-NEXT: DebugLoc: { File: source.c, Line: 60, Column: 5 }343; YAML-NEXT: ...344; YAML-NEXT: --- !Missed345; YAML-NEXT: Pass: loop-vectorize346; YAML-NEXT: Name: MissedDetails347; YAML-NEXT: Function: test_forwardButPreventsForwarding_dep348; YAML-NEXT: Args:349; YAML-NEXT: - String: loop not vectorized350; YAML-NEXT: ...351; YAML-NEXT: --- !Analysis352; YAML-NEXT: Pass: loop-vectorize353; YAML-NEXT: Name: UnsafeDep354; YAML-NEXT: DebugLoc: { File: source.c, Line: 74, Column: 5 }355; YAML-NEXT: Function: test_backwardVectorizableButPreventsForwarding356; YAML-NEXT: Args:357; YAML-NEXT: - String: 'loop not vectorized: '358; 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'359; YAML-NEXT: - String: "\nBackward loop carried data dependence that prevents store-to-load forwarding."360; YAML-NEXT: - String: ' Memory location is the same as accessed at '361; YAML-NEXT: - Location: 'source.c:74:21'362; YAML-NEXT: DebugLoc: { File: source.c, Line: 74, Column: 21 }363; YAML-NEXT: ...364; YAML-NEXT: --- !Missed365; YAML-NEXT: Pass: loop-vectorize366; YAML-NEXT: Name: MissedDetails367; YAML-NEXT: Function: test_backwardVectorizableButPreventsForwarding368; YAML-NEXT: Args:369; YAML-NEXT: - String: loop not vectorized370; YAML-NEXT: ...371; YAML-NEXT: --- !Analysis372; YAML-NEXT: Pass: loop-vectorize373; YAML-NEXT: Name: UnsafeDep374; YAML-NEXT: DebugLoc: { File: source.c, Line: 83, Column: 7 }375; YAML-NEXT: Function: test_unknown_dep376; YAML-NEXT: Args:377; YAML-NEXT: - String: 'loop not vectorized: '378; 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'379; YAML-NEXT: - String: "\nUnknown data dependence."380; YAML-NEXT: - String: ' Memory location is the same as accessed at '381; YAML-NEXT: - Location: 'source.c:82:7'382; YAML-NEXT: DebugLoc: { File: source.c, Line: 82, Column: 7 }383; YAML-NEXT: ...384; YAML-NEXT: --- !Missed385; YAML-NEXT: Pass: loop-vectorize386; YAML-NEXT: Name: MissedDetails387; YAML-NEXT: Function: test_unknown_dep388; YAML-NEXT: Args:389; YAML-NEXT: - String: loop not vectorized390; YAML-NEXT: ...391 392 393!llvm.dbg.cu = !{!0}394!llvm.module.flags = !{!4}395 396!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)397!1 = !DIFile(filename: "source.c", directory: "")398!2 = !{}399!4 = !{i32 2, !"Debug Info Version", i32 3}400!13 = distinct !DISubprogram(name: "test_unknown_bounds", scope: !1, file: !1, line: 2, type: !45, scopeLine: 2, unit: !0, retainedNodes: !2)401!23 = distinct !DILexicalBlock(scope: !13, file: !1, line: 3, column: 5)402!27 = distinct !DILexicalBlock(scope: !23, file: !1, line: 3, column: 5)403!28 = !DILocation(line: 3, column: 5, scope: !23)404!35 = !DILocation(line: 4, column: 16, scope: !27)405!44 = distinct !DISubprogram(name: "test_nodep", scope: !1, file: !1, line: 14, type: !45, scopeLine: 14, unit: !0, retainedNodes: !2)406!45 = !DISubroutineType(types: !46)407!46 = !{null, !18, !16, !16}408!16 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !17, size: 64)409!17 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)410!18 = !DIBasicType(name: "int", size: 64, encoding: DW_ATE_signed)411!52 = distinct !DILexicalBlock(scope: !44, file: !1, line: 15, column: 3)412!56 = distinct !DILexicalBlock(scope: !52, file: !1, line: 15, column: 3)413!60 = distinct !DILexicalBlock(scope: !56, file: !1, line: 15, column: 31)414!61 = !DILocation(line: 16, column: 12, scope: !60)415!63 = !DILocation(line: 16, column: 21, scope: !60)416!70 = distinct !DISubprogram(name: "test_forward", scope: !1, file: !1, line: 24, type: !45, scopeLine: 24, unit: !0, retainedNodes: !2)417!77 = distinct !DILexicalBlock(scope: !70, file: !1, line: 25, column: 3)418!80 = distinct !DILexicalBlock(scope: !77, file: !1, line: 25, column: 3)419!81 = !DILocation(line: 25, column: 3, scope: !77)420!83 = !DILocation(line: 26, column: 5, scope: !84)421!84 = distinct !DILexicalBlock(scope: !80, file: !1, line: 25, column: 28)422!87 = !DILocation(line: 27, column: 12, scope: !84)423!88 = !DILocation(line: 27, column: 5, scope: !84)424!89 = !DILocation(line: 27, column: 10, scope: !84)425!93 = distinct !DISubprogram(name: "test_backwardVectorizable", scope: !1, file: !1, line: 36, type: !95, scopeLine: 36, unit: !0, retainedNodes: !2)426!95 = !DISubroutineType(types: !96)427!96 = !{null, !18, !16}428!99 = distinct !DILexicalBlock(scope: !93, file: !1, line: 37, column: 3)429!103 = distinct !DILexicalBlock(scope: !99, file: !1, line: 37, column: 3)430!106 = !DILocation(line: 38, column: 15, scope: !107)431!107 = distinct !DILexicalBlock(scope: !103, file: !1, line: 37, column: 28)432!108 = !DILocation(line: 38, column: 12, scope: !107)433!110 = !DILocation(line: 38, column: 5, scope: !107)434!111 = !DILocation(line: 38, column: 10, scope: !107)435!136 = distinct !DISubprogram(name: "test_backward_dep", scope: !1, file: !1, line: 45, type: !95, scopeLine: 45, unit: !0, retainedNodes: !2)436!145 = distinct !DILexicalBlock(scope: !136, file: !1, line: 46, column: 3)437!149 = distinct !DILexicalBlock(scope: !145, file: !1, line: 46, column: 3)438!153 = distinct !DILexicalBlock(scope: !149, file: !1, line: 46, column: 39)439!157 = !DILocation(line: 47, column: 5, scope: !153)440!160 = !DILocation(line: 48, column: 14, scope: !153)441!166 = distinct !DISubprogram(name: "test_forwardButPreventsForwarding_dep", scope: !1, file: !1, line: 58, type: !45, scopeLine: 58, unit: !0, retainedNodes: !2)442!172 = distinct !DILexicalBlock(scope: !166, file: !1, line: 59, column: 3)443!176 = distinct !DILexicalBlock(scope: !172, file: !1, line: 59, column: 3)444!179 = !DILocation(line: 60, column: 5, scope: !180)445!180 = distinct !DILexicalBlock(scope: !176, file: !1, line: 59, column: 28)446!183 = !DILocation(line: 61, column: 12, scope: !180)447!189 = distinct !DISubprogram(name: "test_backwardVectorizableButPreventsForwarding", scope: !1, file: !1, line: 72, type: !95, scopeLine: 72, unit: !0, retainedNodes: !2)448!196 = distinct !DILexicalBlock(scope: !189, file: !1, line: 73, column: 3)449!200 = distinct !DILexicalBlock(scope: !196, file: !1, line: 73, column: 3)450!204 = distinct !DILexicalBlock(scope: !200, file: !1, line: 73, column: 29)451!207 = !DILocation(line: 74, column: 21, scope: !204)452!209 = !DILocation(line: 74, column: 5, scope: !204)453!214 = distinct !DISubprogram(name: "test_unknown_dep", scope: !1, file: !1, line: 80, type: !95, scopeLine: 80, unit: !0, retainedNodes: !2)454!219 = distinct !DILexicalBlock(scope: !214, file: !1, line: 81, column: 3)455!223 = distinct !DILexicalBlock(scope: !219, file: !1, line: 81, column: 3)456!227 = distinct !DILexicalBlock(scope: !223, file: !1, line: 81, column: 28)457!229 = !DILocation(line: 82, column: 7, scope: !227)458!231 = !DILocation(line: 83, column: 7, scope: !227)459