[AArch64] Use LateSimplifyCFG after expanding atomic operations.

[bmakam]

Summary

After r308422 we defer optimizations that can destroy loop canonical forms to
LateSimplifyCFG. Running LateSimplifyCFG after expanding atomic operations
can exploit more control-flow opportunities.

[efriedma]

Looks reasonable... but missing testcase.

[bmakam]

Added a testcase. Please take a look.

[bmakam]

Kindly ping.

[efriedma]

test/CodeGen/AArch64/cmpxchg-idioms.ll

121

This testcase looks weird because the loop isn't rotated like it normally would be... might not be guess it's not a big deal.

Please add a short explanation of which CHECK lines are important and why; I assume we're threading a branch somewhere, but it isn't obvious exactly which branch.

[bmakam]

Added a comment in the test case to explain that the preheader is simplified during latesimplifycfg.

[bmakam]

test/CodeGen/AArch64/cmpxchg-idioms.ll

121

The loop wasn't rotated to show the missing simplifyCFG opportunity. This opportunity will be lost when loop is rotated. The preheader block gets simplified after this change and we can elide a branch. Added more CHECK lines and a comment to make it clear.

[efriedma]

LGTM

lib/Target/AArch64/AArch64TargetMachine.cpp

void AArch64PassConfig::addIRPasses() {
   // Always expand atomic operations, we don't deal with atomicrmw or cmpxchg
   // ourselves.
   addPass(createAtomicExpandPass());
 
   // Cmpxchg instructions are often used with a subsequent comparison to
   // determine whether it succeeded. We can exploit existing control-flow in
   // ldrex/strex loops to simplify this, but it needs tidying up.
   if (TM->getOptLevel() != CodeGenOpt::None && EnableAtomicTidy)
-    addPass(createCFGSimplificationPass());
+    addPass(createLateCFGSimplificationPass());
 
   // Run LoopDataPrefetch
   //
   // Run this before LSR to remove the multiplies involved in computing the
   // pointer values N iterations ahead.
   if (TM->getOptLevel() != CodeGenOpt::None) {
     if (EnableLoopDataPrefetch)
       addPass(createLoopDataPrefetchPass());

test/CodeGen/AArch64/aarch64-loop-gep-opt.ll

; CHECK:    br label %do.body.i
 
   %tPos = getelementptr inbounds %typeD, %typeD* %s, i64 0, i32 0
   %k0 = getelementptr inbounds %typeD, %typeD* %s, i64 0, i32 1
   %.pre = load i32, i32* %tPos, align 4
   br label %do.body.i
 
 do.body.i:
 ; CHECK-LABEL: do.body.i:
-; CHECK:          %uglygep1 = getelementptr i8, i8* %uglygep, i64 %3
-; CHECK-NEXT:     %4 = bitcast i8* %uglygep1 to i32*
-; CHECK-NOT:      %uglygep1 = getelementptr i8, i8* %uglygep, i64 1032
+; CHECK:          %uglygep2 = getelementptr i8, i8* %uglygep, i64 %3
+; CHECK-NEXT:     %4 = bitcast i8* %uglygep2 to i32*
+; CHECK-NOT:      %uglygep2 = getelementptr i8, i8* %uglygep, i64 1032
 
 
   %0 = phi i32 [ 256, %entry ], [ %.be, %do.body.i.backedge ]
   %1 = phi i32 [ 0, %entry ], [ %.be6, %do.body.i.backedge ]
   %add.i = add nsw i32 %1, %0
   %shr.i = ashr i32 %add.i, 1
   %idxprom.i = sext i32 %shr.i to i64
   %arrayidx.i = getelementptr inbounds %typeD, %typeD* %s, i64 0, i32 3, i64 %idxprom.i

test/CodeGen/AArch64/cmpxchg-idioms.ll

false:
   br label %end
 
 end:
   ret void
 }
 
 declare void @bar()
 declare void @baz()
+
+define i1 @test_conditional2(i32 %a, i32 %b, i32* %c) {
+; CHECK-LABEL: test_conditional2:
+; CHECK: [[LOOP:LBB[0-9]+_[0-9]+]]:
+; CHECK: ldaxr [[LOADED:w[0-9]+]], [x19]
+; CHECK: cmp [[LOADED]], w21
+; CHECK: b.ne [[FAILED:LBB[0-9]+_[0-9]+]]
+
+; CHECK: stlxr [[STATUS:w[0-9]+]], w20, [x19]
+; CHECK: cbnz [[STATUS]], [[LOOP]]
+; CHECK: orr [[STATUS]], wzr, #0x1
+; CHECK: b [[PH:LBB[0-9]+_[0-9]+]]
+
+; CHECK: [[FAILED]]:
+; CHECK-NOT: cmp {{w[0-9]+}}, {{w[0-9]+}}
+
+; verify the preheader is simplified by latesimplifycfg.
+; CHECK: [[PH]]:
+; CHECK: orr w22, wzr, #0x2
+; CHECK-NOT: orr w22, wzr, #0x4
+; CHECK-NOT: cmn w22, #4
+; CHECK: b [[LOOP2:LBB[0-9]+_[0-9]+]]
+; CHECK-NOT: b.ne [[LOOP2]]
+; CHECK-NOT: b {{LBB[0-9]+_[0-9]+}}
+; CHECK: bl _foo
+entry:
+  %pair = cmpxchg i32* %c, i32 %a, i32 %b seq_cst seq_cst
+  %success = extractvalue { i32, i1 } %pair, 1
+  br label %for.cond
+
+for.cond:                                         ; preds = %if.end, %entry
+  %i.0 = phi i32 [ 2, %entry ], [ %dec, %if.end ]
+  %changed.0.off0 = phi i1 [ %success, %entry ], [ %changed.1.off0, %if.end ]
+  %dec = add nsw i32 %i.0, -1
+  %tobool = icmp eq i32 %i.0, 0
+  br i1 %tobool, label %for.cond.cleanup, label %for.body
+
+for.cond.cleanup:                                 ; preds = %for.cond
+  %changed.0.off0.lcssa = phi i1 [ %changed.0.off0, %for.cond ]
+  ret i1 %changed.0.off0.lcssa
+
+for.body:                                         ; preds = %for.cond
+  %or = or i32 %a, %b
+  %idxprom = sext i32 %dec to i64
+  %arrayidx = getelementptr inbounds i32, i32* %c, i64 %idxprom
+  %0 = load i32, i32* %arrayidx, align 4
+  %cmp = icmp eq i32 %or, %0
+  br i1 %cmp, label %if.end, label %if.then
+
+if.then:                                          ; preds = %for.body
+  store i32 %or, i32* %arrayidx, align 4
+  tail call void @foo()
+  br label %if.end
+
+if.end:                                           ; preds = %for.body, %if.then
+  %changed.1.off0 = phi i1 [ false, %if.then ], [ %changed.0.off0, %for.body ]
+  br label %for.cond
+}
+
+declare void @foo()