[Remarks] Emit variable info in auto-init remarks

[thegameg]

Summary

This enhances the auto-init remark with information about the variable
that is auto-initialized.

This is based of debug info if available, or alloca names (mostly for
development purposes).

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

This allows to see things like partial initialization of a variable that
the optimizer won't be able to completely remove.

[fhahn]

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

66

This just stores references to existing strings, right? Could it just be a StringRef?

70

might be helpful to have a quick comment describing what those do?

llvm/lib/Transforms/Utils/AutoInitRemark.cpp

158

nit: most code in LLVM seems to use regular () for constructors.

llvm/test/Transforms/Util/trivial-auto-var-init-call.ll

293

Not sure I missed a test case, but is there one with multiple variables?

[paquette]

llvm/lib/Transforms/Utils/AutoInitRemark.cpp

42

Might as well merge the ifs to save a line.

164

Do we want to return if FoundDI == true, but Result is empty? Is it possible to get more information from the alloca case even if FoundDI == true?

199

Why uint32_t?

[thegameg]

Address comments + comments in header.

llvm/lib/Transforms/Utils/AutoInitRemark.cpp

158

I use it mostly so I don't have to add a constructor, but I can add one if needed.

199

🤷🏻‍♂️

llvm/test/Transforms/Util/trivial-auto-var-init-call.ll

293

From known_call_with_size_alloca_phi to the end of the file they should all be with multiple variables.

[fhahn]

LGTM, thanks! It might be good to wait a bit with committing, in case Jessica has additional comments.

[paquette]

LGTM!

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

struct AutoInitRemark {
   StringRef RemarkPass;
   const DataLayout &DL;
   const TargetLibraryInfo &TLI;
 
   AutoInitRemark(OptimizationRemarkEmitter &ORE, StringRef RemarkPass,
                  const DataLayout &DL, const TargetLibraryInfo &TLI)
       : ORE(ORE), RemarkPass(RemarkPass), DL(DL), TLI(TLI) {}
 
+  /// Emit a remark using information from the store's destination, size, etc.
   void inspectStore(StoreInst &SI);
+  /// Emit a generic auto-init remark.
   void inspectUnknown(Instruction &I);
+  /// Emit a remark using information from known intrinsic calls.
   void inspectIntrinsicCall(IntrinsicInst &II);
+  /// Emit a remark using information from known function calls.
   void inspectCall(CallInst &CI);
 
 private:
+  /// Add callee information to a remark: whether it's known, the function name,
+  /// etc.
   template <typename FTy>
   void inspectCallee(FTy F, bool KnownLibCall, OptimizationRemarkMissed &R);
+  /// Add operand information to a remark based on knowledge we have for known
+  /// libcalls.
   void inspectKnownLibCall(CallInst &CI, LibFunc LF,
                            OptimizationRemarkMissed &R);
+  /// Add the memory operation size to a remark.
   void inspectSizeOperand(Value *V, OptimizationRemarkMissed &R);
+
+  struct VariableInfo {
+    Optional<StringRef> Name;
+    Optional<uint64_t> Size;
+    bool isEmpty() const { return !Name && !Size; }
+  };
+  /// Gather more information about \p V as a variable. This can be debug info,
+  /// information from the alloca, etc. Since \p V can represent more than a
+  /// single variable, they will all be added to the remark.
+  void inspectDst(Value *Dst, OptimizationRemarkMissed &R);
+  void inspectVariable(const Value *V, SmallVectorImpl<VariableInfo> &Result);
 };
 
 } // namespace llvm
 
 #endif

llvm/lib/Transforms/Utils/AutoInitRemark.cpp

 //===-- AutoInitRemark.cpp - Auto-init remark analysis---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Implementation of the analysis for the "auto-init" remark.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Utils/AutoInitRemark.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
+#include "llvm/Analysis/ValueTracking.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
+#include "llvm/Transforms/Utils/Local.h"
 
 using namespace llvm;
 using namespace llvm::ore;
 
 static void volatileOrAtomicWithExtraArgs(bool Volatile, bool Atomic,
                                           OptimizationRemarkMissed &R) {
   if (Volatile)
     R << " Volatile: " << NV("StoreVolatile", true) << ".";
   if (Atomic)
     R << " Atomic: " << NV("StoreAtomic", true) << ".";
   // Emit StoreVolatile: false and StoreAtomic: false under ExtraArgs. This
   // won't show them in the remark message but will end up in the serialized
   // remarks.
   if (!Volatile || !Atomic)
     R << setExtraArgs();
   if (!Volatile)
     R << " Volatile: " << NV("StoreVolatile", false) << ".";
   if (!Atomic)
     R << " Atomic: " << NV("StoreAtomic", false) << ".";
 }
 
+static Optional<uint64_t> getSizeInBytes(Optional<uint64_t> SizeInBits) {
+  if (!SizeInBits || *SizeInBits % 8 != 0)
+    return None;
+  return *SizeInBits / 8;
+}
+
 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.";
+  inspectDst(SI.getOperand(1), R);
   volatileOrAtomicWithExtraArgs(Volatile, Atomic, R);
   ORE.emit(R);
 }
 
 void AutoInitRemark::inspectUnknown(Instruction &I) {
   ORE.emit(OptimizationRemarkMissed(RemarkPass.data(),
                                     "AutoInitUnknownInstruction", &I)
            << "Initialization inserted by -ftrivial-auto-var-init.");
void AutoInitRemark::inspectIntrinsicCall(IntrinsicInst &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();
+  inspectDst(II.getOperand(0), R);
   volatileOrAtomicWithExtraArgs(Volatile, Atomic, R);
   ORE.emit(R);
 }
 
 void AutoInitRemark::inspectCall(CallInst &CI) {
   Function *F = CI.getCalledFunction();
   if (!F)
     return inspectUnknown(CI);

 
 void AutoInitRemark::inspectKnownLibCall(CallInst &CI, LibFunc LF,
                                          OptimizationRemarkMissed &R) {
   switch (LF) {
   default:
     return;
   case LibFunc_bzero:
     inspectSizeOperand(CI.getOperand(1), R);
+    inspectDst(CI.getOperand(0), 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.";
   }
 }
+
+void AutoInitRemark::inspectVariable(const Value *V,
+                                     SmallVectorImpl<VariableInfo> &Result) {
+  // If we find some information in the debug info, take that.
+  bool FoundDI = false;
+  // Try to get an llvm.dbg.declare, which has a DILocalVariable giving us the
+  // real debug info name and size of the variable.
+  for (const DbgVariableIntrinsic *DVI :
+       FindDbgAddrUses(const_cast<Value *>(V))) {
+    if (DILocalVariable *DILV = DVI->getVariable()) {
+      Optional<uint64_t> DISize = getSizeInBytes(DILV->getSizeInBits());
+      VariableInfo Var{DILV->getName(), DISize};
+      if (!Var.isEmpty()) {
+        Result.push_back(std::move(Var));
+        FoundDI = true;
+      }
+    }
+  }
+  if (FoundDI) {
+    assert(!Result.empty());
+    return;
+  }
+
+  const auto *AI = dyn_cast<AllocaInst>(V);
+  if (!AI)
+    return;
+
+  // If not, get it from the alloca.
+  Optional<StringRef> Name = AI->hasName()
+                                 ? Optional<StringRef>(AI->getName())
+                                 : Optional<StringRef>(None);
+  Optional<TypeSize> TySize = AI->getAllocationSizeInBits(DL);
+  Optional<uint64_t> Size =
+      TySize ? getSizeInBytes(TySize->getFixedSize()) : None;
+  VariableInfo Var{Name, Size};
+  if (!Var.isEmpty())
+    Result.push_back(std::move(Var));
+}
+
+void AutoInitRemark::inspectDst(Value *Dst, OptimizationRemarkMissed &R) {
+  // Find if Dst is a known variable we can give more information on.
+  SmallVector<const Value *, 2> Objects;
+  getUnderlyingObjects(Dst, Objects);
+  SmallVector<VariableInfo, 2> VIs;
+  for (const Value *V : Objects)
+    inspectVariable(V, VIs);
+
+  if (VIs.empty())
+    return;
+
+  R << "\nVariables: ";
+  for (unsigned i = 0; i < VIs.size(); ++i) {
+    const VariableInfo &VI = VIs[i];
+    assert(!VI.isEmpty() && "No extra content to display.");
+    if (i != 0)
+      R << ", ";
+    if (VI.Name)
+      R << NV("VarName", *VI.Name);
+    else
+      R << NV("VarName", "<unknown>");
+    if (VI.Size)
+      R << " (" << NV("VarSize", *VI.Size) << " bytes)";
+  }
+  R << ".";
+}

llvm/test/Transforms/Util/trivial-auto-var-init-call.ll

; YAML-NEXT: ...
   call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %dst, i8* align 1 %src, i64 %size, i32 1), !annotation !0, !dbg !DILocation(scope: !4)
   ret void
 }
 
 ; Emit remarks for memcpy, memmove, memset, bzero with known constant sizes to
 ; an alloca.
 define void @known_call_with_size_alloca(i8* %src) {
 ; CHECK-NEXT: Call to memset inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst (1 bytes).
 ; YAML-LABEL: --- !Missed
 ; YAML-NEXT: Pass:            annotation-remarks
 ; YAML-NEXT: Name:            AutoInitIntrinsic
 ; YAML-NEXT: DebugLoc:
 ; YAML-NEXT: Function:        known_call_with_size_alloca
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - String:          'Call to '
 ; YAML-NEXT:   - Callee:          memset
 ; YAML-NEXT:   - String:          ' inserted by -ftrivial-auto-var-init.'
 ; YAML-NEXT:   - String:          ' Memory operation size: '
 ; YAML-NEXT:   - StoreSize:       '1'
 ; YAML-NEXT:   - String:          ' bytes.'
+; YAML-NEXT:   - String:          "\nVariables: "
+; YAML-NEXT:   - VarName:         dst
+; YAML-NEXT:   - String:          ' ('
+; YAML-NEXT:   - VarSize:         '1'
+; YAML-NEXT:   - String:          ' bytes)'
+; YAML-NEXT:   - String:          .
 ; YAML-NEXT:   - String:          ' Volatile: '
 ; YAML-NEXT:   - StoreVolatile:   'false'
 ; YAML-NEXT:   - String:          .
 ; YAML-NEXT:   - String:          ' Atomic: '
 ; YAML-NEXT:   - StoreAtomic:     'false'
 ; YAML-NEXT:   - String:          .
 ; YAML-NEXT: ...
   %dst = alloca i8
   call void @llvm.memset.p0i8.i64(i8* %dst, i8 0, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to memcpy inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst (1 bytes).
 ; YAML-LABEL: --- !Missed
 ; YAML-NEXT: Pass:            annotation-remarks
 ; YAML-NEXT: Name:            AutoInitIntrinsic
 ; YAML-NEXT: DebugLoc:
 ; YAML-NEXT: Function:        known_call_with_size_alloca
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - String:          'Call to '
 ; YAML-NEXT:   - Callee:          memcpy
 ; YAML-NEXT:   - String:          ' inserted by -ftrivial-auto-var-init.'
 ; YAML-NEXT:   - String:          ' Memory operation size: '
 ; YAML-NEXT:   - StoreSize:       '1'
 ; YAML-NEXT:   - String:          ' bytes.'
+; YAML-NEXT:   - String:          "\nVariables: "
+; YAML-NEXT:   - VarName:         dst
+; YAML-NEXT:   - String:          ' ('
+; YAML-NEXT:   - VarSize:         '1'
+; YAML-NEXT:   - String:          ' bytes)'
+; YAML-NEXT:   - String:          .
 ; YAML-NEXT:   - String:          ' Volatile: '
 ; YAML-NEXT:   - StoreVolatile:   'false'
 ; YAML-NEXT:   - String:          .
 ; YAML-NEXT:   - String:          ' Atomic: '
 ; YAML-NEXT:   - StoreAtomic:     'false'
 ; YAML-NEXT:   - String:          .
 ; YAML-NEXT: ...
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to memmove inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst (1 bytes).
 ; YAML-LABEL: --- !Missed
 ; YAML-NEXT: Pass:            annotation-remarks
 ; YAML-NEXT: Name:            AutoInitIntrinsic
 ; YAML-NEXT: DebugLoc:
 ; YAML-NEXT: Function:        known_call_with_size_alloca
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - String:          'Call to '
 ; YAML-NEXT:   - Callee:          memmove
 ; YAML-NEXT:   - String:          ' inserted by -ftrivial-auto-var-init.'
 ; YAML-NEXT:   - String:          ' Memory operation size: '
 ; YAML-NEXT:   - StoreSize:       '1'
 ; YAML-NEXT:   - String:          ' bytes.'
+; YAML-NEXT:   - String:          "\nVariables: "
+; YAML-NEXT:   - VarName:         dst
+; YAML-NEXT:   - String:          ' ('
+; YAML-NEXT:   - VarSize:         '1'
+; YAML-NEXT:   - String:          ' bytes)'
+; YAML-NEXT:   - String:          .
 ; YAML-NEXT:   - String:          ' Volatile: '
 ; YAML-NEXT:   - StoreVolatile:   'false'
 ; YAML-NEXT:   - String:          .
 ; YAML-NEXT:   - String:          ' Atomic: '
 ; YAML-NEXT:   - StoreAtomic:     'false'
 ; YAML-NEXT:   - String:          .
 ; YAML-NEXT: ...
   call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to bzero inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst (1 bytes).
 ; YAML-LABEL: --- !Missed
 ; YAML-NEXT: Pass:            annotation-remarks
 ; YAML-NEXT: Name:            AutoInitCall
 ; YAML-NEXT: DebugLoc:
 ; YAML-NEXT: Function:        known_call_with_size_alloca
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - String:          'Call to '
 ; YAML-NEXT:   - Callee:          bzero
 ; YAML-NEXT:   - String:          ' inserted by -ftrivial-auto-var-init.'
 ; YAML-NEXT:   - String:          ' Memory operation size: '
 ; YAML-NEXT:   - StoreSize:       '1'
 ; YAML-NEXT:   - String:          ' bytes.'
+; YAML-NEXT:   - String:          "\nVariables: "
+; YAML-NEXT:   - VarName:         dst
+; YAML-NEXT:   - String:          ' ('
+; YAML-NEXT:   - VarSize:         '1'
+; YAML-NEXT:   - String:          ' bytes)'
+; YAML-NEXT:   - String:          .
 ; YAML-NEXT: ...
   call void @bzero(i8* %dst, i64 1), !annotation !0, !dbg !DILocation(scope: !4)
 
   ret void
 }
 
 ; Emit remarks for memcpy, memmove, memset, bzero with known constant sizes to
 ; an alloca through a GEP.
 define void @known_call_with_size_alloca_gep(i8* %src) {
 ; CHECK-NEXT: Call to memset inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst (1 bytes).
   %dst = alloca i8
   %gep = getelementptr i8, i8* %dst, i32 0
   call void @llvm.memset.p0i8.i64(i8* %gep, i8 0, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to memcpy inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst (1 bytes).
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %gep, i8* %src, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to memmove inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst (1 bytes).
   call void @llvm.memmove.p0i8.p0i8.i64(i8* %gep, i8* %src, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to bzero inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst (1 bytes).
   call void @bzero(i8* %gep, i64 1), !annotation !0, !dbg !DILocation(scope: !4)
   ret void
 }
 
 ; Emit remarks for memcpy, memmove, memset, bzero with known constant sizes to
 ; an alloca through a GEP in an array.
 define void @known_call_with_size_alloca_gep_array(i8* %src) {
 ; CHECK-NEXT: Call to memset inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst (2 bytes).
   %dst = alloca [2 x i8]
   %gep = getelementptr [2 x i8], [2 x i8]* %dst, i64 0, i64 0
   call void @llvm.memset.p0i8.i64(i8* %gep, i8 0, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to memcpy inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst (2 bytes).
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %gep, i8* %src, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to memmove inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst (2 bytes).
   call void @llvm.memmove.p0i8.p0i8.i64(i8* %gep, i8* %src, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to bzero inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst (2 bytes).
   call void @bzero(i8* %gep, i64 1), !annotation !0, !dbg !DILocation(scope: !4)
   ret void
 }
 
 ; Emit remarks for memcpy, memmove, memset, bzero with known constant sizes to
 ; an alloca through a bitcast.
 define void @known_call_with_size_alloca_bitcast(i8* %src) {
 ; CHECK-NEXT: Call to memset inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst (2 bytes).
   %dst = alloca [2 x i8]
   %bc = bitcast [2 x i8]* %dst to i8*
   call void @llvm.memset.p0i8.i64(i8* %bc, i8 0, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to memcpy inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst (2 bytes).
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %bc, i8* %src, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to memmove inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst (2 bytes).
   call void @llvm.memmove.p0i8.p0i8.i64(i8* %bc, i8* %src, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to bzero inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst (2 bytes).
   call void @bzero(i8* %bc, i64 1), !annotation !0, !dbg !DILocation(scope: !4)
   ret void
 }
 
 ; Emit remarks for memcpy, memmove, memset, bzero with known constant sizes to an alloca that has a DILocalVariable attached.
 define void @known_call_with_size_alloca_di(i8* %src) {
 ; CHECK-NEXT: Call to memset inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: destination (1 bytes).
   %dst = alloca i8
   call void @llvm.dbg.declare(metadata i8* %dst, metadata !6, metadata !DIExpression()), !dbg !DILocation(scope: !4)
   call void @llvm.memset.p0i8.i64(i8* %dst, i8 0, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to memcpy inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: destination (1 bytes).
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to memmove inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: destination (1 bytes).
   call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to bzero inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: destination (1 bytes).
   call void @bzero(i8* %dst, i64 1), !annotation !0, !dbg !DILocation(scope: !4)
   ret void
 }
 
 ; Emit remarks for memcpy, memmove, memset, bzero with known constant sizes to
 ; an alloca that has more than one DILocalVariable attached.
 define void @known_call_with_size_alloca_di_multiple(i8* %src) {
 ; CHECK-NEXT: Call to memset inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: destination (1 bytes).
   %dst = alloca i8
   call void @llvm.dbg.declare(metadata i8* %dst, metadata !6, metadata !DIExpression()), !dbg !DILocation(scope: !4)
   call void @llvm.memset.p0i8.i64(i8* %dst, i8 0, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to memcpy inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: destination (1 bytes).
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to memmove inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: destination (1 bytes).
   call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to bzero inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: destination (1 bytes).
   call void @bzero(i8* %dst, i64 1), !annotation !0, !dbg !DILocation(scope: !4)
   ret void
 }
 
 ; Emit remarks for memcpy, memmove, memset, bzero with known constant sizes to
 ; a PHI node that can be two different allocas.
 define void @known_call_with_size_alloca_phi(i8* %src) {
 ; CHECK-NEXT: Call to memset inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst2 (1 bytes), dst (1 bytes).
 entry:
   %dst = alloca i8
   %dst2 = alloca i8
   %cmp = icmp eq i32 undef, undef
   br i1 %cmp, label %l0, label %l1
 l0:
   br label %l2
 l1:
   br label %l2
 l2:
   %phidst = phi i8* [ %dst, %l0 ], [ %dst2, %l1 ]
   call void @llvm.memset.p0i8.i64(i8* %phidst, i8 0, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to memcpy inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst2 (1 bytes), dst (1 bytes).
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %phidst, i8* %src, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to memmove inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst2 (1 bytes), dst (1 bytes).
   call void @llvm.memmove.p0i8.p0i8.i64(i8* %phidst, i8* %src, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to bzero inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst2 (1 bytes), dst (1 bytes).
   call void @bzero(i8* %phidst, i64 1), !annotation !0, !dbg !DILocation(scope: !4)
   ret void
 }
 
 ; Emit remarks for memcpy, memmove, memset, bzero with known constant sizes to
 ; a PHI node that can be two different allocas, where one of it has multiple
 ; DILocalVariable.
 define void @known_call_with_size_alloca_phi_di_multiple(i8* %src) {
 ; CHECK-NEXT: Call to memset inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst2 (1 bytes), destination2 (1 bytes), destination (1 bytes).
 entry:
   %dst = alloca i8
   %dst2 = alloca i8
   call void @llvm.dbg.declare(metadata i8* %dst, metadata !6, metadata !DIExpression()), !dbg !DILocation(scope: !4)
   call void @llvm.dbg.declare(metadata i8* %dst, metadata !7, metadata !DIExpression()), !dbg !DILocation(scope: !4)
   %cmp = icmp eq i32 undef, undef
   br i1 %cmp, label %l0, label %l1
 l0:
   br label %l2
 l1:
   br label %l2
 l2:
   %phidst = phi i8* [ %dst, %l0 ], [ %dst2, %l1 ]
   call void @llvm.memset.p0i8.i64(i8* %phidst, i8 0, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to memcpy inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst2 (1 bytes), destination2 (1 bytes), destination (1 bytes).
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %phidst, i8* %src, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to memmove inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst2 (1 bytes), destination2 (1 bytes), destination (1 bytes).
   call void @llvm.memmove.p0i8.p0i8.i64(i8* %phidst, i8* %src, i64 1, i1 false), !annotation !0, !dbg !DILocation(scope: !4)
 ; CHECK-NEXT: Call to bzero inserted by -ftrivial-auto-var-init. Memory operation size: 1 bytes.
+; CHECK-NEXT: Variables: dst2 (1 bytes), destination2 (1 bytes), destination (1 bytes).
   call void @bzero(i8* %phidst, i64 1), !annotation !0, !dbg !DILocation(scope: !4)
   ret void
 }
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata) nounwind readnone speculatable willreturn
 declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) argmemonly nounwind willreturn writeonly
 declare void @llvm.memmove.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i1 immarg) argmemonly nounwind willreturn
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i64, i1 immarg) argmemonly nounwind willreturn

llvm/test/Transforms/Util/trivial-auto-var-init-store.ll

; YAML-NEXT: ...
   store atomic i32 0, i32* %dst unordered, align 4, !annotation !0, !dbg !DILocation(scope: !4)
   ret void
 }
 
 ; Emit a remark that reports a store to an alloca.
 define void @store_alloca() {
 ; CHECK-NEXT: Store inserted by -ftrivial-auto-var-init.
 ; CHECK-NEXT: Store size: 4 bytes.
+; CHECK-NEXT: Variables: dst (4 bytes).
 ; YAML-LABEL: --- !Missed
 ; YAML-NEXT: Pass:            annotation-remarks
 ; YAML-NEXT: Name:            AutoInitStore
 ; YAML-NEXT: DebugLoc:
 ; YAML-NEXT: Function:        store_alloca
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - String:          "Store inserted by -ftrivial-auto-var-init.\nStore size: "
 ; YAML-NEXT:   - StoreSize:       '4'
 ; YAML-NEXT:   - String:          ' bytes.'
+; YAML-NEXT:   - String:          "\nVariables: "
+; YAML-NEXT:   - VarName:         dst
+; YAML-NEXT:   - String:          ' ('
+; YAML-NEXT:   - VarSize:         '4'
+; YAML-NEXT:   - String:          ' bytes)'
+; YAML-NEXT:   - String:          .
 ; YAML-NEXT:   - String:          ' Volatile: '
-; YAML-NEXT:   - StoreVolatile:       'false'
+; YAML-NEXT:   - StoreVolatile:    'false'
 ; YAML-NEXT:   - String:          .
 ; YAML-NEXT:   - String:          ' Atomic: '
-; YAML-NEXT:   - StoreAtomic:       'false'
+; YAML-NEXT:   - StoreAtomic:     'false'
 ; YAML-NEXT:   - String:          .
 ; YAML-NEXT: ...
   %dst = alloca i32
   store i32 0, i32* %dst, !annotation !0, !dbg !DILocation(scope: !4)
   ret void
 }
 
 ; Emit a remark that reports a store to an alloca through a GEP.
 define void @store_alloca_gep() {
 ; CHECK-NEXT: Store inserted by -ftrivial-auto-var-init.
 ; CHECK-NEXT: Store size: 4 bytes.
+; CHECK-NEXT: Variables: dst (4 bytes).
   %dst = alloca i32
   %gep = getelementptr i32, i32* %dst, i32 0
   store i32 0, i32* %gep, !annotation !0, !dbg !DILocation(scope: !4)
   ret void
 }
 
 ; Emit a remark that reports a store to an alloca through a GEP in an array.
 define void @store_alloca_gep_array() {
 ; CHECK-NEXT: Store inserted by -ftrivial-auto-var-init.
 ; CHECK-NEXT: Store size: 4 bytes.
+; CHECK-NEXT: Variables: dst (8 bytes).
   %dst = alloca [2 x i32]
   %gep = getelementptr [2 x i32], [2 x i32]* %dst, i64 0, i64 0
   store i32 0, i32* %gep, !annotation !0, !dbg !DILocation(scope: !4)
   ret void
 }
 
 ; Emit a remark that reports a store to an alloca through a bitcast.
 define void @store_alloca_bitcast() {
 ; CHECK-NEXT: Store inserted by -ftrivial-auto-var-init.
 ; CHECK-NEXT: Store size: 4 bytes.
+; CHECK-NEXT: Variables: dst (4 bytes).
   %dst = alloca [2 x i16]
   %bc = bitcast [2 x i16]* %dst to i32*
   store i32 0, i32* %bc, !annotation !0, !dbg !DILocation(scope: !4)
   ret void
 }
 
 ; Emit a remark that reports a store to an alloca that has a DILocalVariable
 ; attached.
 define void @store_alloca_di() {
 ; CHECK-NEXT: Store inserted by -ftrivial-auto-var-init.
 ; CHECK-NEXT: Store size: 4 bytes.
+; CHECK-NEXT: Variables: destination (4 bytes).
   %dst = alloca i32
   store i32 0, i32* %dst, !annotation !0, !dbg !DILocation(scope: !4)
   call void @llvm.dbg.declare(metadata i32* %dst, metadata !6, metadata !DIExpression()), !dbg !DILocation(scope: !4)
   ret void
 }
 
 ; Emit a remark that reports a store to an alloca that has more than one
 ; DILocalVariable attached.
 define void @store_alloca_di_multiple() {
 ; CHECK-NEXT: Store inserted by -ftrivial-auto-var-init.
 ; CHECK-NEXT: Store size: 4 bytes.
+; CHECK-NEXT: Variables: destination2 (4 bytes), destination (4 bytes).
   %dst = alloca i32
   store i32 0, i32* %dst, !annotation !0, !dbg !DILocation(scope: !4)
   call void @llvm.dbg.declare(metadata i32* %dst, metadata !6, metadata !DIExpression()), !dbg !DILocation(scope: !4)
   call void @llvm.dbg.declare(metadata i32* %dst, metadata !7, metadata !DIExpression()), !dbg !DILocation(scope: !4)
   ret void
 }
 
 ; Emit a remark that reports a store to a PHI node that can be two different
 ; allocas.
 define void @store_alloca_phi() {
 ; CHECK-NEXT: Store inserted by -ftrivial-auto-var-init.
 ; CHECK-NEXT: Store size: 4 bytes.
+; CHECK-NEXT: Variables: dst2 (4 bytes), dst (4 bytes).
 entry:
   %dst = alloca i32
   %dst2 = alloca i32
   %cmp = icmp eq i32 undef, undef
   br i1 %cmp, label %l0, label %l1
 l0:
   br label %l2
 l1:
   br label %l2
 l2:
   %phidst = phi i32* [ %dst, %l0 ], [ %dst2, %l1 ]
   store i32 0, i32* %phidst, !annotation !0, !dbg !DILocation(scope: !4)
   ret void
 }
 
 ; Emit a remark that reports a store to a PHI node that can be two different
 ; allocas, where one of it has multiple DILocalVariable.
 define void @store_alloca_phi_di_multiple() {
 ; CHECK-NEXT: Store inserted by -ftrivial-auto-var-init.
 ; CHECK-NEXT: Store size: 4 bytes.
+; CHECK-NEXT: Variables: dst2 (4 bytes), destination2 (4 bytes), destination (4 bytes).
 entry:
   %dst = alloca i32
   %dst2 = alloca i32
   call void @llvm.dbg.declare(metadata i32* %dst, metadata !6, metadata !DIExpression()), !dbg !DILocation(scope: !4)
   call void @llvm.dbg.declare(metadata i32* %dst, metadata !7, metadata !DIExpression()), !dbg !DILocation(scope: !4)
   %cmp = icmp eq i32 undef, undef
   br i1 %cmp, label %l0, label %l1
 l0: