[AArch64TargetMachine] Enable LICM Hosting LOAD only optimization in case of -O3

[djtodoro]

Summary

Enable LICM Hosting LOAD only optimization in case of -O3.

NOTE: This doesn't depend on the SeparateConstOffsetFromGEP, but the flag for this optimization will be enabled iff the SeparateConstOffsetFromGEP is active in the case of AARCH64 target, which is the goal arch for this stack of patches.

This addresses [0].
[0] https://bugs.llvm.org/show_bug.cgi?id=51193

Co-authored-by: @mmatic05, @milica-lazarevic, @dmilosevic141

[efriedma]

Not sure why you want to turn it on specifically for aarch64, and only late in the optimization pipeline.

llvm/lib/Transforms/Scalar/LICM.cpp

336

You can't mess with a global variable like this; among other issues, it breaks thread safety. If you need a variable, add a member to the LegacyLICMPass class.

[djtodoro]

@efriedma Thanks for the comment!

In D113290#3135380, @efriedma wrote:

Not sure why you want to turn it on specifically for aarch64, and only late in the optimization pipeline.

Actually, it doesn't need to be called very late. And, I don't think this is applicable to AArch64 only.
I've been experimenting with a few potential improvements in LLVM that could bring benefits to AArch64 Aggressive optimization mode, so this patch just follows that direction (that's why it was marked as WIP).

[djtodoro]

This isn't needed, since the feature will be target-independent.

llvm/include/llvm/Transforms/Scalar.h

 // use a single canonical induction variable per loop.
 //
 Pass *createIndVarSimplifyPass();
 
 //===----------------------------------------------------------------------===//
 //
 // LICM - This pass is a loop invariant code motion and memory promotion pass.
 //
-Pass *createLICMPass();
+Pass *createLICMPass(bool TryHoistingLoadOnly = false);
 Pass *createLICMPass(unsigned LicmMssaOptCap,
                      unsigned LicmMssaNoAccForPromotionCap);
 
 //===----------------------------------------------------------------------===//
 //
 // LoopSink - This pass sinks invariants from preheader to loop body where
 // frequency is lower than loop preheader.
 //

llvm/lib/Target/AArch64/AArch64TargetMachine.cpp

if (TM->getOptLevel() == CodeGenOpt::Aggressive && EnableGEPOpt) {
     // can optimize.
     addPass(createGVNPass());
     addPass(createNaryReassociatePass());
     // Call EarlyCSE pass to find and remove subexpressions in the lowered
     // result.
     addPass(createEarlyCSEPass());
     // Do loop invariant code motion in case part of the lowered result is
     // invariant.
-    addPass(createLICMPass());
+    addPass(createLICMPass(/*TryHoistingLoadOnly*/ true));
   }
 
   // Add Control Flow Guard checks.
   if (TM->getTargetTriple().isOSWindows())
     addPass(createCFGuardCheckPass());
 }
 
 // Pass Pipeline Configuration

llvm/lib/Transforms/Scalar/LICM.cpp

 INITIALIZE_PASS_DEPENDENCY(LoopPass)
 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(MemorySSAWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(LazyBFIPass)
 INITIALIZE_PASS_END(LegacyLICMPass, "licm", "Loop Invariant Code Motion", false,
                     false)
 
-Pass *llvm::createLICMPass() { return new LegacyLICMPass(); }
+Pass *llvm::createLICMPass(bool TryHoistingLoadOnly) {
+  EnableLoadHoistOnly = TryHoistingLoadOnly;
+  return new LegacyLICMPass();
+}
 Pass *llvm::createLICMPass(unsigned LicmMssaOptCap,
                            unsigned LicmMssaNoAccForPromotionCap) {
   return new LegacyLICMPass(LicmMssaOptCap, LicmMssaNoAccForPromotionCap);
 }
 
 llvm::SinkAndHoistLICMFlags::SinkAndHoistLICMFlags(bool IsSink, Loop *L,
                                                    MemorySSA *MSSA)
     : SinkAndHoistLICMFlags(SetLicmMssaOptCap, SetLicmMssaNoAccForPromotionCap,

llvm/test/Transforms/LICM/AArch64/hoist-load-without-store.ll

 ;; C reproducer:
 ;; int u, v;
 ;;
 ;; void f(int a[restrict], int b[restrict], int n) {
 ;;     for (int i = 0; i < n; ++i) {
 ;;         if (a[i]) {
 ;;             ++u;
 ;;             break;
 ;;         }
 ;;         ++u;
 ;;         if (b[i])
 ;;             ++v;
 ;;     }
 ;; }
 
 ; RUN: opt -licm -licm-load-hoisting-only -mtriple aarch64-linux-gnu -S < %s | FileCheck %s
+; RUN: llc -O3 -print-after=codegenprepare < %s 2>&1 | FileCheck %s
 
 ; CHECK-LABEL: for.body.preheader:
-; CHECK: %u.promoted = load i32, i32* @u
-; CHECK: %v.promoted = load i32, i32* @v
+; CHECK: load i32, i32* @u
+; CHECK-NEXT: load i32, i32* @v
+; CHECK-NEXT: br label %for.body
 
 ; ModuleID = './test.ll'
 source_filename = "test.c"
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64-unknown-linux"
 
 @u = dso_local local_unnamed_addr global i32 0, align 4
 @v = dso_local local_unnamed_addr global i32 0, align 4

 !6 = !{i32 7, !"frame-pointer", i32 1}
 !7 = !{!"clang version 14.0.0"}
 !8 = !{!9, !9, i64 0}
 !9 = !{!"int", !10, i64 0}
 !10 = !{!"omnipotent char", !11, i64 0}
 !11 = !{!"Simple C/C++ TBAA"}
 !12 = distinct !{!12, !13}
 !13 = !{!"llvm.loop.mustprogress"}
 No newline at end of file