[Remarks] Provide more information about auto-init calls

This now analyzes calls to both intrinsics and functions.

For intrinsics, grab the ones we know and care about (mem* family) and
analyze the arguments.

For calls, use TLI to get more information about the libcalls, then
analyze the arguments if known.

```
auto-init.c:4:7: remark: Call to memset inserted by -ftrivial-auto-var-init. Memory operation size: 4096 bytes. [-Rpass-missed=annotation-remarks]
  int var[1024];
      ^
```

Differential Revision: https://reviews.llvm.org/D97489

Author: francisvm

llvm/include/llvm/Transforms/Utils/AutoInitRemark.h

@@ -16,27 +16,42 @@
 #define LLVM_TRANSFORMS_UTILS_AUTOINITREMARK_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
 
 namespace llvm {
 
-class StoreInst;
+class CallInst;
+class DataLayout;
 class Instruction;
+class IntrinsicInst;
+class Value;
 class OptimizationRemarkEmitter;
-class DataLayout;
+class OptimizationRemarkMissed;
+class StoreInst;
 
 // FIXME: Once we get to more remarks like this one, we need to re-evaluate how
 // much of this logic should actually go into the remark emitter.
 struct AutoInitRemark {
   OptimizationRemarkEmitter &ORE;
   StringRef RemarkPass;
   const DataLayout &DL;
+  const TargetLibraryInfo &TLI;
 
   AutoInitRemark(OptimizationRemarkEmitter &ORE, StringRef RemarkPass,
-                 const DataLayout &DL)
-      : ORE(ORE), RemarkPass(RemarkPass), DL(DL) {}
+                 const DataLayout &DL, const TargetLibraryInfo &TLI)
+      : ORE(ORE), RemarkPass(RemarkPass), DL(DL), TLI(TLI) {}
 
   void inspectStore(StoreInst &SI);
   void inspectUnknown(Instruction &I);
+  void inspectIntrinsicCall(IntrinsicInst &II);
+  void inspectCall(CallInst &CI);
+
+private:
+  template <typename FTy>
+  void inspectCallee(FTy F, bool KnownLibCall, OptimizationRemarkMissed &R);
+  void inspectKnownLibCall(CallInst &CI, LibFunc LF,
+                           OptimizationRemarkMissed &R);
+  void inspectSizeOperand(Value *V, OptimizationRemarkMissed &R);
 };
 
 } // namespace llvm

llvm/lib/Transforms/Scalar/AnnotationRemarks.cpp

@@ -17,6 +17,7 @@
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Debug.h"
@@ -30,7 +31,8 @@ using namespace llvm::ore;
 #define REMARK_PASS DEBUG_TYPE
 
 static void tryEmitAutoInitRemark(ArrayRef<Instruction *> Instructions,
-                                  OptimizationRemarkEmitter &ORE) {
+                                  OptimizationRemarkEmitter &ORE,
+                                  const TargetLibraryInfo &TLI) {
   // For every auto-init annotation generate a separate remark.
   for (Instruction *I : Instructions) {
     if (!I->hasMetadata(LLVMContext::MD_annotation))
@@ -42,7 +44,7 @@ static void tryEmitAutoInitRemark(ArrayRef<Instruction *> Instructions,
 
       Function &F = *I->getParent()->getParent();
       const DataLayout &DL = F.getParent()->getDataLayout();
-      AutoInitRemark Remark(ORE, REMARK_PASS, DL);
+      AutoInitRemark Remark(ORE, REMARK_PASS, DL, TLI);
       // For some of them, we can provide more information:
 
       // For stores:
@@ -53,12 +55,29 @@ static void tryEmitAutoInitRemark(ArrayRef<Instruction *> Instructions,
         continue;
       }
 
+      // For intrinsics:
+      // * user-friendly name
+      // * size
+      if (auto *II = dyn_cast<IntrinsicInst>(I)) {
+        Remark.inspectIntrinsicCall(*II);
+        continue;
+      }
+
+      // For calls:
+      // * known/unknown function (e.g. the compiler knows bzero, but it doesn't
+      //                                know my_bzero)
+      // * memory operation size
+      if (auto *CI = dyn_cast<CallInst>(I)) {
+        Remark.inspectCall(*CI);
+        continue;
+      }
+
       Remark.inspectUnknown(*I);
     }
   }
 }
 
-static void runImpl(Function &F) {
+static void runImpl(Function &F, const TargetLibraryInfo &TLI) {
   if (!OptimizationRemarkEmitter::allowExtraAnalysis(F, REMARK_PASS))
     return;
 
@@ -94,7 +113,7 @@ static void runImpl(Function &F) {
     if (!KV.first)
       continue;
 
-    tryEmitAutoInitRemark(KV.second, ORE);
+    tryEmitAutoInitRemark(KV.second, ORE, TLI);
   }
 }
 
@@ -108,12 +127,15 @@ struct AnnotationRemarksLegacy : public FunctionPass {
   }
 
   bool runOnFunction(Function &F) override {
-    runImpl(F);
+    const TargetLibraryInfo &TLI =
+        getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
+    runImpl(F, TLI);
     return false;
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
+    AU.addRequired<TargetLibraryInfoWrapperPass>();
   }
 };
 
@@ -123,6 +145,7 @@ char AnnotationRemarksLegacy::ID = 0;
 
 INITIALIZE_PASS_BEGIN(AnnotationRemarksLegacy, "annotation-remarks",
                       "Annotation Remarks", false, false)
+INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 INITIALIZE_PASS_END(AnnotationRemarksLegacy, "annotation-remarks",
                     "Annotation Remarks", false, false)
 
@@ -132,6 +155,7 @@ FunctionPass *llvm::createAnnotationRemarksLegacyPass() {
 
 PreservedAnalyses AnnotationRemarksPass::run(Function &F,
                                              FunctionAnalysisManager &AM) {
-  runImpl(F);
+  auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
+  runImpl(F, TLI);
   return PreservedAnalyses::all();
 }

llvm/lib/Transforms/Utils/AutoInitRemark.cpp

@@ -13,18 +13,13 @@
 #include "llvm/Transforms/Utils/AutoInitRemark.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
 
 using namespace llvm;
 using namespace llvm::ore;
 
-void AutoInitRemark::inspectStore(StoreInst &SI) {
-  bool Volatile = SI.isVolatile();
-  bool Atomic = SI.isAtomic();
-  int64_t Size = DL.getTypeStoreSize(SI.getOperand(0)->getType());
-
-  OptimizationRemarkMissed R(RemarkPass.data(), "AutoInitStore", &SI);
-  R << "Store inserted by -ftrivial-auto-var-init.\nStore size: "
-    << NV("StoreSize", Size) << " bytes.";
+static void volatileOrAtomicWithExtraArgs(bool Volatile, bool Atomic,
+                                          OptimizationRemarkMissed &R) {
   if (Volatile)
     R << " Volatile: " << NV("StoreVolatile", true) << ".";
   if (Atomic)
@@ -38,7 +33,17 @@ void AutoInitRemark::inspectStore(StoreInst &SI) {
     R << " Volatile: " << NV("StoreVolatile", false) << ".";
   if (!Atomic)
     R << " Atomic: " << NV("StoreAtomic", false) << ".";
+}
+
+void AutoInitRemark::inspectStore(StoreInst &SI) {
+  bool Volatile = SI.isVolatile();
+  bool Atomic = SI.isAtomic();
+  int64_t Size = DL.getTypeStoreSize(SI.getOperand(0)->getType());
 
+  OptimizationRemarkMissed R(RemarkPass.data(), "AutoInitStore", &SI);
+  R << "Store inserted by -ftrivial-auto-var-init.\nStore size: "
+    << NV("StoreSize", Size) << " bytes.";
+  volatileOrAtomicWithExtraArgs(Volatile, Atomic, R);
   ORE.emit(R);
 }
 
@@ -47,3 +52,83 @@ void AutoInitRemark::inspectUnknown(Instruction &I) {
                                     "AutoInitUnknownInstruction", &I)
            << "Initialization inserted by -ftrivial-auto-var-init.");
 }
+
+void AutoInitRemark::inspectIntrinsicCall(IntrinsicInst &II) {
+  SmallString<32> CallTo;
+  bool Atomic = false;
+  switch (II.getIntrinsicID()) {
+  case Intrinsic::memcpy:
+    CallTo = "memcpy";
+    break;
+  case Intrinsic::memmove:
+    CallTo = "memmove";
+    break;
+  case Intrinsic::memset:
+    CallTo = "memset";
+    break;
+  case Intrinsic::memcpy_element_unordered_atomic:
+    CallTo = "memcpy";
+    Atomic = true;
+    break;
+  case Intrinsic::memmove_element_unordered_atomic:
+    CallTo = "memmove";
+    Atomic = true;
+    break;
+  case Intrinsic::memset_element_unordered_atomic:
+    CallTo = "memset";
+    Atomic = true;
+    break;
+  default:
+    return inspectUnknown(II);
+  }
+
+  OptimizationRemarkMissed R(RemarkPass.data(), "AutoInitIntrinsic", &II);
+  inspectCallee(StringRef(CallTo), /*KnownLibCall=*/true, R);
+  inspectSizeOperand(II.getOperand(2), R);
+
+  auto *CIVolatile = dyn_cast<ConstantInt>(II.getOperand(3));
+  // No such thing as a memory intrinsic that is both atomic and volatile.
+  bool Volatile = !Atomic && CIVolatile && CIVolatile->getZExtValue();
+  volatileOrAtomicWithExtraArgs(Volatile, Atomic, R);
+  ORE.emit(R);
+}
+
+void AutoInitRemark::inspectCall(CallInst &CI) {
+  Function *F = CI.getCalledFunction();
+  if (!F)
+    return inspectUnknown(CI);
+
+  LibFunc LF;
+  bool KnownLibCall = TLI.getLibFunc(*F, LF) && TLI.has(LF);
+  OptimizationRemarkMissed R(RemarkPass.data(), "AutoInitCall", &CI);
+  inspectCallee(F, KnownLibCall, R);
+  inspectKnownLibCall(CI, LF, R);
+  ORE.emit(R);
+}
+
+template <typename FTy>
+void AutoInitRemark::inspectCallee(FTy F, bool KnownLibCall,
+                                   OptimizationRemarkMissed &R) {
+  R << "Call to ";
+  if (!KnownLibCall)
+    R << NV("UnknownLibCall", "unknown") << " function ";
+  R << NV("Callee", F) << " inserted by -ftrivial-auto-var-init.";
+}
+
+void AutoInitRemark::inspectKnownLibCall(CallInst &CI, LibFunc LF,
+                                         OptimizationRemarkMissed &R) {
+  switch (LF) {
+  default:
+    return;
+  case LibFunc_bzero:
+    inspectSizeOperand(CI.getOperand(1), R);
+    break;
+  }
+}
+
+void AutoInitRemark::inspectSizeOperand(Value *V, OptimizationRemarkMissed &R) {
+  if (auto *Len = dyn_cast<ConstantInt>(V)) {
+    uint64_t Size = Len->getZExtValue();
+    R << " Memory operation size: " << NV("StoreSize", Size) << " bytes.";
+  }
+}

llvm/test/Other/new-pm-O0-defaults.ll

@@ -44,6 +44,7 @@
 ; CHECK-LTO-NEXT: Running pass: LowerTypeTestsPass
 ; CHECK-LTO-NEXT: Running pass: LowerTypeTestsPass
 ; CHECK-LTO-NEXT: Running pass: AnnotationRemarksPass
+; CHECK-LTO-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-NEXT: Running pass: PrintModulePass
 
 ; Make sure we get the IR back out without changes when we print the module.