646 lines · plain
1; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 42; RUN: opt -passes='print<access-info>' -disable-output < %s 2>&1 | FileCheck %s3 4target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"5 6; Following cases are no dependence.7 8; void nodep_Read_Write(int *A) {9; int *B = A + 1;10; for (unsigned i = 0; i < 1024; i+=3)11; B[i] = A[i] + 1;12; }13 14define void @nodep_Read_Write(ptr nocapture %A) {15; CHECK-LABEL: 'nodep_Read_Write'16; CHECK-NEXT: for.body:17; CHECK-NEXT: Memory dependences are safe18; CHECK-NEXT: Dependences:19; CHECK-NEXT: Run-time memory checks:20; CHECK-NEXT: Grouped accesses:21; CHECK-EMPTY:22; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.23; CHECK-NEXT: SCEV assumptions:24; CHECK-EMPTY:25; CHECK-NEXT: Expressions re-written:26;27entry:28 %add.ptr = getelementptr inbounds i32, ptr %A, i64 129 br label %for.body30 31for.cond.cleanup: ; preds = %for.body32 ret void33 34for.body: ; preds = %entry, %for.body35 %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]36 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv37 %0 = load i32, ptr %arrayidx, align 438 %add = add nsw i32 %0, 139 %arrayidx2 = getelementptr inbounds i32, ptr %add.ptr, i64 %indvars.iv40 store i32 %add, ptr %arrayidx2, align 441 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 342 %cmp = icmp ult i64 %indvars.iv.next, 102443 br i1 %cmp, label %for.body, label %for.cond.cleanup44}45 46; int nodep_Write_Read(int *A) {47; int sum = 0;48; for (unsigned i = 0; i < 1024; i+=4) {49; A[i] = i;50; sum += A[i+3];51; }52;53; return sum;54; }55 56define i32 @nodep_Write_Read(ptr nocapture %A) {57; CHECK-LABEL: 'nodep_Write_Read'58; CHECK-NEXT: for.body:59; CHECK-NEXT: Memory dependences are safe60; CHECK-NEXT: Dependences:61; CHECK-NEXT: Run-time memory checks:62; CHECK-NEXT: Grouped accesses:63; CHECK-EMPTY:64; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.65; CHECK-NEXT: SCEV assumptions:66; CHECK-EMPTY:67; CHECK-NEXT: Expressions re-written:68;69entry:70 br label %for.body71 72for.cond.cleanup: ; preds = %for.body73 ret i32 %add374 75for.body: ; preds = %entry, %for.body76 %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]77 %sum.013 = phi i32 [ 0, %entry ], [ %add3, %for.body ]78 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv79 %0 = trunc i64 %indvars.iv to i3280 store i32 %0, ptr %arrayidx, align 481 %1 = or disjoint i64 %indvars.iv, 382 %arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %183 %2 = load i32, ptr %arrayidx2, align 484 %add3 = add nsw i32 %2, %sum.01385 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 486 %cmp = icmp ult i64 %indvars.iv.next, 102487 br i1 %cmp, label %for.body, label %for.cond.cleanup88}89 90; void nodep_Write_Write(int *A) {91; for (unsigned i = 0; i < 1024; i+=2) {92; A[i] = i;93; A[i+1] = i+1;94; }95; }96 97define void @nodep_Write_Write(ptr nocapture %A) {98; CHECK-LABEL: 'nodep_Write_Write'99; CHECK-NEXT: for.body:100; CHECK-NEXT: Memory dependences are safe101; CHECK-NEXT: Dependences:102; CHECK-NEXT: Run-time memory checks:103; CHECK-NEXT: Grouped accesses:104; CHECK-EMPTY:105; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.106; CHECK-NEXT: SCEV assumptions:107; CHECK-EMPTY:108; CHECK-NEXT: Expressions re-written:109;110entry:111 br label %for.body112 113for.cond.cleanup: ; preds = %for.body114 ret void115 116for.body: ; preds = %entry, %for.body117 %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]118 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv119 %0 = trunc i64 %indvars.iv to i32120 store i32 %0, ptr %arrayidx, align 4121 %1 = or disjoint i64 %indvars.iv, 1122 %arrayidx3 = getelementptr inbounds i32, ptr %A, i64 %1123 %2 = trunc i64 %1 to i32124 store i32 %2, ptr %arrayidx3, align 4125 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2126 %cmp = icmp ult i64 %indvars.iv.next, 1024127 br i1 %cmp, label %for.body, label %for.cond.cleanup128}129 130; Following cases are unsafe depdences and are not vectorizable.131 132; void unsafe_Read_Write(int *A) {133; for (unsigned i = 0; i < 1024; i+=3)134; A[i+3] = A[i] + 1;135; }136 137define void @unsafe_Read_Write(ptr nocapture %A) {138; CHECK-LABEL: 'unsafe_Read_Write'139; CHECK-NEXT: for.body:140; CHECK-NEXT: Report: 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 loop141; CHECK-NEXT: Backward loop carried data dependence.142; CHECK-NEXT: Dependences:143; CHECK-NEXT: Backward:144; CHECK-NEXT: %0 = load i32, ptr %arrayidx, align 4 ->145; CHECK-NEXT: store i32 %add, ptr %arrayidx3, align 4146; CHECK-EMPTY:147; CHECK-NEXT: Run-time memory checks:148; CHECK-NEXT: Grouped accesses:149; CHECK-EMPTY:150; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.151; CHECK-NEXT: SCEV assumptions:152; CHECK-EMPTY:153; CHECK-NEXT: Expressions re-written:154;155entry:156 br label %for.body157 158for.cond.cleanup: ; preds = %for.body159 ret void160 161for.body: ; preds = %entry, %for.body162 %i.010 = phi i32 [ 0, %entry ], [ %add1, %for.body ]163 %idxprom = zext i32 %i.010 to i64164 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %idxprom165 %0 = load i32, ptr %arrayidx, align 4166 %add = add nsw i32 %0, 1167 %add1 = add i32 %i.010, 3168 %idxprom2 = zext i32 %add1 to i64169 %arrayidx3 = getelementptr inbounds i32, ptr %A, i64 %idxprom2170 store i32 %add, ptr %arrayidx3, align 4171 %cmp = icmp ult i32 %add1, 1024172 br i1 %cmp, label %for.body, label %for.cond.cleanup173}174 175; int unsafe_Write_Read(int *A) {176; int sum = 0;177; for (unsigned i = 0; i < 1024; i+=4) {178; A[i] = i;179; sum += A[i+4];180; }181;182; return sum;183; }184 185define i32 @unsafe_Write_Read(ptr nocapture %A) {186; CHECK-LABEL: 'unsafe_Write_Read'187; CHECK-NEXT: for.body:188; CHECK-NEXT: Report: 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 loop189; CHECK-NEXT: Backward loop carried data dependence.190; CHECK-NEXT: Dependences:191; CHECK-NEXT: Backward:192; CHECK-NEXT: store i32 %0, ptr %arrayidx, align 4 ->193; CHECK-NEXT: %1 = load i32, ptr %arrayidx2, align 4194; CHECK-EMPTY:195; CHECK-NEXT: Run-time memory checks:196; CHECK-NEXT: Grouped accesses:197; CHECK-EMPTY:198; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.199; CHECK-NEXT: SCEV assumptions:200; CHECK-EMPTY:201; CHECK-NEXT: Expressions re-written:202;203entry:204 br label %for.body205 206for.cond.cleanup: ; preds = %for.body207 ret i32 %add3208 209for.body: ; preds = %entry, %for.body210 %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]211 %sum.013 = phi i32 [ 0, %entry ], [ %add3, %for.body ]212 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv213 %0 = trunc i64 %indvars.iv to i32214 store i32 %0, ptr %arrayidx, align 4215 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 4216 %arrayidx2 = getelementptr inbounds i32, ptr %A, i64 %indvars.iv.next217 %1 = load i32, ptr %arrayidx2, align 4218 %add3 = add nsw i32 %1, %sum.013219 %cmp = icmp ult i64 %indvars.iv.next, 1024220 br i1 %cmp, label %for.body, label %for.cond.cleanup221}222 223; void unsafe_Write_Write(int *A) {224; for (unsigned i = 0; i < 1024; i+=2) {225; A[i] = i;226; A[i+2] = i+1;227; }228; }229 230define void @unsafe_Write_Write(ptr nocapture %A) {231; CHECK-LABEL: 'unsafe_Write_Write'232; CHECK-NEXT: for.body:233; CHECK-NEXT: Report: 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 loop234; CHECK-NEXT: Backward loop carried data dependence.235; CHECK-NEXT: Dependences:236; CHECK-NEXT: Backward:237; CHECK-NEXT: store i32 %0, ptr %arrayidx, align 4 ->238; CHECK-NEXT: store i32 %2, ptr %arrayidx3, align 4239; CHECK-EMPTY:240; CHECK-NEXT: Run-time memory checks:241; CHECK-NEXT: Grouped accesses:242; CHECK-EMPTY:243; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.244; CHECK-NEXT: SCEV assumptions:245; CHECK-EMPTY:246; CHECK-NEXT: Expressions re-written:247;248entry:249 br label %for.body250 251for.cond.cleanup: ; preds = %for.body252 ret void253 254for.body: ; preds = %entry, %for.body255 %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]256 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv257 %0 = trunc i64 %indvars.iv to i32258 store i32 %0, ptr %arrayidx, align 4259 %1 = or disjoint i64 %indvars.iv, 1260 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2261 %arrayidx3 = getelementptr inbounds i32, ptr %A, i64 %indvars.iv.next262 %2 = trunc i64 %1 to i32263 store i32 %2, ptr %arrayidx3, align 4264 %cmp = icmp ult i64 %indvars.iv.next, 1024265 br i1 %cmp, label %for.body, label %for.cond.cleanup266}267 268; Following cases check that strided accesses can be vectorized.269 270; void vectorizable_Read_Write(int *A) {271; int *B = A + 4;272; for (unsigned i = 0; i < 1024; i+=2)273; B[i] = A[i] + 1;274; }275 276define void @vectorizable_Read_Write(ptr nocapture %A) {277; CHECK-LABEL: 'vectorizable_Read_Write'278; CHECK-NEXT: for.body:279; CHECK-NEXT: Memory dependences are safe with a maximum safe vector width of 64 bits, with a maximum safe store-load forward width of 64 bits280; CHECK-NEXT: Dependences:281; CHECK-NEXT: BackwardVectorizable:282; CHECK-NEXT: %0 = load i32, ptr %arrayidx, align 4 ->283; CHECK-NEXT: store i32 %add, ptr %arrayidx2, align 4284; CHECK-EMPTY:285; CHECK-NEXT: Run-time memory checks:286; CHECK-NEXT: Grouped accesses:287; CHECK-EMPTY:288; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.289; CHECK-NEXT: SCEV assumptions:290; CHECK-EMPTY:291; CHECK-NEXT: Expressions re-written:292;293entry:294 %add.ptr = getelementptr inbounds i32, ptr %A, i64 4295 br label %for.body296 297for.cond.cleanup: ; preds = %for.body298 ret void299 300for.body: ; preds = %entry, %for.body301 %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]302 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv303 %0 = load i32, ptr %arrayidx, align 4304 %add = add nsw i32 %0, 1305 %arrayidx2 = getelementptr inbounds i32, ptr %add.ptr, i64 %indvars.iv306 store i32 %add, ptr %arrayidx2, align 4307 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2308 %cmp = icmp ult i64 %indvars.iv.next, 1024309 br i1 %cmp, label %for.body, label %for.cond.cleanup310}311 312; int vectorizable_Write_Read(int *A) {313; int *B = A + 4;314; int sum = 0;315; for (unsigned i = 0; i < 1024; i+=2) {316; A[i] = i;317; sum += B[i];318; }319;320; return sum;321; }322 323define i32 @vectorizable_Write_Read(ptr nocapture %A) {324; CHECK-LABEL: 'vectorizable_Write_Read'325; CHECK-NEXT: for.body:326; CHECK-NEXT: Memory dependences are safe with a maximum safe vector width of 64 bits327; CHECK-NEXT: Dependences:328; CHECK-NEXT: BackwardVectorizable:329; CHECK-NEXT: store i32 %0, ptr %arrayidx, align 4 ->330; CHECK-NEXT: %1 = load i32, ptr %arrayidx2, align 4331; CHECK-EMPTY:332; CHECK-NEXT: Run-time memory checks:333; CHECK-NEXT: Grouped accesses:334; CHECK-EMPTY:335; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.336; CHECK-NEXT: SCEV assumptions:337; CHECK-EMPTY:338; CHECK-NEXT: Expressions re-written:339;340entry:341 %add.ptr = getelementptr inbounds i32, ptr %A, i64 4342 br label %for.body343 344for.cond.cleanup: ; preds = %for.body345 ret i32 %add346 347for.body: ; preds = %entry, %for.body348 %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]349 %sum.013 = phi i32 [ 0, %entry ], [ %add, %for.body ]350 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv351 %0 = trunc i64 %indvars.iv to i32352 store i32 %0, ptr %arrayidx, align 4353 %arrayidx2 = getelementptr inbounds i32, ptr %add.ptr, i64 %indvars.iv354 %1 = load i32, ptr %arrayidx2, align 4355 %add = add nsw i32 %1, %sum.013356 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2357 %cmp = icmp ult i64 %indvars.iv.next, 1024358 br i1 %cmp, label %for.body, label %for.cond.cleanup359}360 361; void vectorizable_Write_Write(int *A) {362; int *B = A + 4;363; for (unsigned i = 0; i < 1024; i+=2) {364; A[i] = i;365; B[i] = i+1;366; }367; }368 369define void @vectorizable_Write_Write(ptr nocapture %A) {370; CHECK-LABEL: 'vectorizable_Write_Write'371; CHECK-NEXT: for.body:372; CHECK-NEXT: Memory dependences are safe with a maximum safe vector width of 64 bits373; CHECK-NEXT: Dependences:374; CHECK-NEXT: BackwardVectorizable:375; CHECK-NEXT: store i32 %0, ptr %arrayidx, align 4 ->376; CHECK-NEXT: store i32 %2, ptr %arrayidx2, align 4377; CHECK-EMPTY:378; CHECK-NEXT: Run-time memory checks:379; CHECK-NEXT: Grouped accesses:380; CHECK-EMPTY:381; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.382; CHECK-NEXT: SCEV assumptions:383; CHECK-EMPTY:384; CHECK-NEXT: Expressions re-written:385;386entry:387 %add.ptr = getelementptr inbounds i32, ptr %A, i64 4388 br label %for.body389 390for.cond.cleanup: ; preds = %for.body391 ret void392 393for.body: ; preds = %entry, %for.body394 %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]395 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv396 %0 = trunc i64 %indvars.iv to i32397 store i32 %0, ptr %arrayidx, align 4398 %1 = or disjoint i64 %indvars.iv, 1399 %arrayidx2 = getelementptr inbounds i32, ptr %add.ptr, i64 %indvars.iv400 %2 = trunc i64 %1 to i32401 store i32 %2, ptr %arrayidx2, align 4402 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2403 %cmp = icmp ult i64 %indvars.iv.next, 1024404 br i1 %cmp, label %for.body, label %for.cond.cleanup405}406 407; void vectorizable_unscaled_Read_Write(int *A) {408; int *B = (int *)((char *)A + 14);409; for (unsigned i = 0; i < 1024; i+=2)410; B[i] = A[i] + 1;411; }412 413; FIXME: This case looks like previous case @vectorizable_Read_Write. It sould414; be vectorizable.415 416define void @vectorizable_unscaled_Read_Write(ptr nocapture %A) {417; CHECK-LABEL: 'vectorizable_unscaled_Read_Write'418; CHECK-NEXT: for.body:419; CHECK-NEXT: Report: 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 loop420; CHECK-NEXT: Backward loop carried data dependence that prevents store-to-load forwarding.421; CHECK-NEXT: Dependences:422; CHECK-NEXT: BackwardVectorizableButPreventsForwarding:423; CHECK-NEXT: %0 = load i32, ptr %arrayidx, align 4 ->424; CHECK-NEXT: store i32 %add, ptr %arrayidx2, align 4425; CHECK-EMPTY:426; CHECK-NEXT: Run-time memory checks:427; CHECK-NEXT: Grouped accesses:428; CHECK-EMPTY:429; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.430; CHECK-NEXT: SCEV assumptions:431; CHECK-EMPTY:432; CHECK-NEXT: Expressions re-written:433;434entry:435 %add.ptr = getelementptr inbounds i8, ptr %A, i64 14436 br label %for.body437 438for.cond.cleanup: ; preds = %for.body439 ret void440 441for.body: ; preds = %entry, %for.body442 %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]443 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv444 %0 = load i32, ptr %arrayidx, align 4445 %add = add nsw i32 %0, 1446 %arrayidx2 = getelementptr inbounds i32, ptr %add.ptr, i64 %indvars.iv447 store i32 %add, ptr %arrayidx2, align 4448 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2449 %cmp = icmp ult i64 %indvars.iv.next, 1024450 br i1 %cmp, label %for.body, label %for.cond.cleanup451}452 453; int vectorizable_unscaled_Write_Read(int *A) {454; int *B = (int *)((char *)A + 17);455; int sum = 0;456; for (unsigned i = 0; i < 1024; i+=2) {457; A[i] = i;458; sum += B[i];459; }460;461; return sum;462; }463 464define i32 @vectorizable_unscaled_Write_Read(ptr nocapture %A) {465; CHECK-LABEL: 'vectorizable_unscaled_Write_Read'466; CHECK-NEXT: for.body:467; CHECK-NEXT: Memory dependences are safe with a maximum safe vector width of 64 bits468; CHECK-NEXT: Dependences:469; CHECK-NEXT: BackwardVectorizable:470; CHECK-NEXT: store i32 %0, ptr %arrayidx, align 4 ->471; CHECK-NEXT: %1 = load i32, ptr %arrayidx2, align 4472; CHECK-EMPTY:473; CHECK-NEXT: Run-time memory checks:474; CHECK-NEXT: Grouped accesses:475; CHECK-EMPTY:476; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.477; CHECK-NEXT: SCEV assumptions:478; CHECK-EMPTY:479; CHECK-NEXT: Expressions re-written:480;481entry:482 %add.ptr = getelementptr inbounds i8, ptr %A, i64 17483 br label %for.body484 485for.cond.cleanup: ; preds = %for.body486 ret i32 %add487 488for.body: ; preds = %entry, %for.body489 %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]490 %sum.013 = phi i32 [ 0, %entry ], [ %add, %for.body ]491 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv492 %0 = trunc i64 %indvars.iv to i32493 store i32 %0, ptr %arrayidx, align 4494 %arrayidx2 = getelementptr inbounds i32, ptr %add.ptr, i64 %indvars.iv495 %1 = load i32, ptr %arrayidx2, align 4496 %add = add nsw i32 %1, %sum.013497 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2498 %cmp = icmp ult i64 %indvars.iv.next, 1024499 br i1 %cmp, label %for.body, label %for.cond.cleanup500}501 502; void unsafe_unscaled_Read_Write(int *A) {503; int *B = (int *)((char *)A + 11);504; for (unsigned i = 0; i < 1024; i+=2)505; B[i] = A[i] + 1;506; }507 508define void @unsafe_unscaled_Read_Write(ptr nocapture %A) {509; CHECK-LABEL: 'unsafe_unscaled_Read_Write'510; CHECK-NEXT: for.body:511; CHECK-NEXT: Report: 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 loop512; CHECK-NEXT: Backward loop carried data dependence.513; CHECK-NEXT: Dependences:514; CHECK-NEXT: Backward:515; CHECK-NEXT: %0 = load i32, ptr %arrayidx, align 4 ->516; CHECK-NEXT: store i32 %add, ptr %arrayidx2, align 4517; CHECK-EMPTY:518; CHECK-NEXT: Run-time memory checks:519; CHECK-NEXT: Grouped accesses:520; CHECK-EMPTY:521; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.522; CHECK-NEXT: SCEV assumptions:523; CHECK-EMPTY:524; CHECK-NEXT: Expressions re-written:525;526entry:527 %add.ptr = getelementptr inbounds i8, ptr %A, i64 11528 br label %for.body529 530for.cond.cleanup: ; preds = %for.body531 ret void532 533for.body: ; preds = %entry, %for.body534 %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]535 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv536 %0 = load i32, ptr %arrayidx, align 4537 %add = add nsw i32 %0, 1538 %arrayidx2 = getelementptr inbounds i32, ptr %add.ptr, i64 %indvars.iv539 store i32 %add, ptr %arrayidx2, align 4540 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2541 %cmp = icmp ult i64 %indvars.iv.next, 1024542 br i1 %cmp, label %for.body, label %for.cond.cleanup543}544 545; void unsafe_unscaled_Read_Write2(int *A) {546; int *B = (int *)((char *)A + 1);547; for (unsigned i = 0; i < 1024; i+=2)548; B[i] = A[i] + 1;549; }550 551define void @unsafe_unscaled_Read_Write2(ptr nocapture %A) {552; CHECK-LABEL: 'unsafe_unscaled_Read_Write2'553; CHECK-NEXT: for.body:554; CHECK-NEXT: Report: 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 loop555; CHECK-NEXT: Backward loop carried data dependence.556; CHECK-NEXT: Dependences:557; CHECK-NEXT: Backward:558; CHECK-NEXT: %0 = load i32, ptr %arrayidx, align 4 ->559; CHECK-NEXT: store i32 %add, ptr %arrayidx2, align 4560; CHECK-EMPTY:561; CHECK-NEXT: Run-time memory checks:562; CHECK-NEXT: Grouped accesses:563; CHECK-EMPTY:564; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.565; CHECK-NEXT: SCEV assumptions:566; CHECK-EMPTY:567; CHECK-NEXT: Expressions re-written:568;569entry:570 %add.ptr = getelementptr inbounds i8, ptr %A, i64 1571 br label %for.body572 573for.cond.cleanup: ; preds = %for.body574 ret void575 576for.body: ; preds = %entry, %for.body577 %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]578 %arrayidx = getelementptr inbounds i32, ptr %A, i64 %indvars.iv579 %0 = load i32, ptr %arrayidx, align 4580 %add = add nsw i32 %0, 1581 %arrayidx2 = getelementptr inbounds i32, ptr %add.ptr, i64 %indvars.iv582 store i32 %add, ptr %arrayidx2, align 4583 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2584 %cmp = icmp ult i64 %indvars.iv.next, 1024585 br i1 %cmp, label %for.body, label %for.cond.cleanup586}587 588; Following case checks that interleaved stores have dependences with another589; store and can not pass dependence check.590 591; void interleaved_stores(int *A) {592; int *B = (int *) ((char *)A + 1);593; for(int i = 0; i < 1024; i+=2) {594; B[i] = i; // (1)595; A[i+1] = i + 1; // (2)596; B[i+1] = i + 1; // (3)597; }598; }599;600; The access (2) has overlaps with (1) and (3).601 602define void @interleaved_stores(ptr nocapture %A) {603; CHECK-LABEL: 'interleaved_stores'604; CHECK-NEXT: for.body:605; CHECK-NEXT: Report: 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 loop606; CHECK-NEXT: Backward loop carried data dependence.607; CHECK-NEXT: Dependences:608; CHECK-NEXT: Backward:609; CHECK-NEXT: store i32 %2, ptr %arrayidx5, align 4 ->610; CHECK-NEXT: store i32 %2, ptr %arrayidx9, align 4611; CHECK-EMPTY:612; CHECK-NEXT: Backward:613; CHECK-NEXT: store i32 %0, ptr %arrayidx2, align 4 ->614; CHECK-NEXT: store i32 %2, ptr %arrayidx5, align 4615; CHECK-EMPTY:616; CHECK-NEXT: Run-time memory checks:617; CHECK-NEXT: Grouped accesses:618; CHECK-EMPTY:619; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.620; CHECK-NEXT: SCEV assumptions:621; CHECK-EMPTY:622; CHECK-NEXT: Expressions re-written:623;624entry:625 %incdec.ptr = getelementptr inbounds i8, ptr %A, i64 1626 br label %for.body627 628for.cond.cleanup: ; preds = %for.body629 ret void630 631for.body: ; preds = %entry, %for.body632 %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]633 %0 = trunc i64 %indvars.iv to i32634 %arrayidx2 = getelementptr inbounds i32, ptr %incdec.ptr, i64 %indvars.iv635 store i32 %0, ptr %arrayidx2, align 4636 %1 = or disjoint i64 %indvars.iv, 1637 %arrayidx5 = getelementptr inbounds i32, ptr %A, i64 %1638 %2 = trunc i64 %1 to i32639 store i32 %2, ptr %arrayidx5, align 4640 %arrayidx9 = getelementptr inbounds i32, ptr %incdec.ptr, i64 %1641 store i32 %2, ptr %arrayidx9, align 4642 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2643 %cmp = icmp slt i64 %indvars.iv.next, 1024644 br i1 %cmp, label %for.body, label %for.cond.cleanup645}646