[LICM] Allow freeze to hoist/sink out of a loop

[aqjune]

Summary

This patch allows LICM to hoist/sink freeze instructions out of a loop.

[lebedev.ri]

llvm/lib/Transforms/Scalar/LICM.cpp

1235–1237

Should there be a standalone test for this?

[aqjune]

Update

[aqjune]

Update

[aqjune]

There was a confusion about the meaning of sink - I thought it was about moving an instruction from outside of the loop to inside.
freeze is allowed to move from inside to outside of a loop, including both hoist and sink.
I added a test for sink too.

[lebedev.ri]

SGTM

[aqjune]

Clang-format

[aqjune]

This is a small change - may I land this patch?

[reames]

LGTM

llvm/lib/Transforms/Scalar/LICM.cpp

 
 namespace {
 /// Return true if-and-only-if we know how to (mechanically) both hoist and
 /// sink a given instruction out of a loop.  Does not address legality
 /// concerns such as aliasing or speculation safety.
 bool isHoistableAndSinkableInst(Instruction &I) {
   // Only these instructions are hoistable/sinkable.
   return (isa<LoadInst>(I) || isa<StoreInst>(I) || isa<CallInst>(I) ||
-          isa<FenceInst>(I) || isa<CastInst>(I) ||
-          isa<UnaryOperator>(I) || isa<BinaryOperator>(I) ||
-          isa<SelectInst>(I) || isa<GetElementPtrInst>(I) || isa<CmpInst>(I) ||
+          isa<FenceInst>(I) || isa<CastInst>(I) || isa<UnaryOperator>(I) ||
+          isa<BinaryOperator>(I) || isa<SelectInst>(I) ||
+          isa<GetElementPtrInst>(I) || isa<CmpInst>(I) ||
           isa<InsertElementInst>(I) || isa<ExtractElementInst>(I) ||
           isa<ShuffleVectorInst>(I) || isa<ExtractValueInst>(I) ||
-          isa<InsertValueInst>(I));
+          isa<InsertValueInst>(I) || isa<FreezeInst>(I));
 }
 /// Return true if all of the alias sets within this AST are known not to
 /// contain a Mod, or if MSSA knows thare are no MemoryDefs in the loop.
 bool isReadOnly(AliasSetTracker *CurAST, const MemorySSAUpdater *MSSAU,
                 const Loop *L) {
   if (CurAST) {
     for (AliasSet &AS : *CurAST) {
       if (!AS.isForwardingAliasSet() && AS.isMod()) {
if (CurAST) {
 
       auto *Source = MSSA->getSkipSelfWalker()->getClobberingMemoryAccess(SI);
       Flags->LicmMssaOptCounter++;
       // If there are no clobbering Defs in the loop, store is safe to hoist.
       return MSSA->isLiveOnEntryDef(Source) ||
              !CurLoop->contains(Source->getBlock());
     }
   }
 
   assert(!I.mayReadOrWriteMemory() && "unhandled aliasing");
 
   // We've established mechanical ability and aliasing, it's up to the caller
   // to check fault safety
   return true;
 }
 
 /// Returns true if a PHINode is a trivially replaceable with an
 /// Instruction.
 /// This is true when all incoming values are that instruction.

llvm/test/Transforms/LICM/freeze.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -licm -S < %s | FileCheck %s
+
+define void @hoist(i1 %a) {
+; CHECK-LABEL: @hoist(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[B:%.*]] = freeze i1 [[A:%.*]]
+; CHECK-NEXT:    br label [[LOOP:%.*]]
+; CHECK:       loop:
+; CHECK-NEXT:    call void @use(i1 [[B]])
+; CHECK-NEXT:    br label [[LOOP]]
+;
+entry:
+  br label %loop
+loop:
+  %b = freeze i1 %a
+  call void @use(i1 %b)
+  br label %loop
+}
+
+define i1 @sink(i1 %a) {
+; CHECK-LABEL: @sink(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br label [[LOOP:%.*]]
+; CHECK:       loop:
+; CHECK-NEXT:    [[C:%.*]] = call i1 @cond()
+; CHECK-NEXT:    br i1 [[C]], label [[LOOP]], label [[EXIT:%.*]]
+; CHECK:       exit:
+; CHECK-NEXT:    [[FR_LE:%.*]] = freeze i1 [[A:%.*]]
+; CHECK-NEXT:    ret i1 [[FR_LE]]
+;
+entry:
+  br label %loop
+loop:
+  %fr = freeze i1 %a
+  %c = call i1 @cond()
+  br i1 %c, label %loop, label %exit
+exit:
+  ret i1 %fr
+}
+
+declare i1 @cond()
+declare void @use(i1)