Output per-function size-info remarks

[paquette]

Summary

This patch adds per-function size information remarks. Previously, passing -Rpass-analysis=size-info would only give you per-module changes.

By adding the ability to do this per-function, it's easier to see which functions contributed the most to size changes.

(Note that we still have a random function name attached to the remark which is kind of misleading. Since we want to emit remarks for deleted functions as well, we can't use the function we're emitting the remark for in the OptimizationRemarkAnalysis. I put a FIXME in for this, but if there's a better way around it, it'd be nice to avoid the issue entirely.)

[thegameg]

Other than the comments it LGTM, thanks!

lib/IR/LegacyPassManager.cpp

191

Why not FunctionToInstrCount[F.getName().str()] = std::pair<unsigned, unsigned>(0, FnSize); as used previously in initSizeRemarkInfo?

238

You may be able to avoid using BB by calling the DiagnosticInfoIROptimization constructor directly.

[paquette]

I ran this with a debug build, and I noticed it's pretty heavy wrt compile time. I'm working on fixing that before committing.

Also, @anemet asked me offline to provide some opt-stats output. Here's that for sqlite3 at -O2 + size remarks:

Total number of remarks 56884

Top 10 remarks by pass:

gvn                            56%
licm                           21%
inline                         15%
loop-vectorize                  4%
slp-vectorizer                  2%
prologepilog                    1%
asm-printer                     1%
regalloc                        0%
loop-unroll                     0%
tailcallelim                    0%

Top 10 remarks:

gvn/LoadClobbered              54%
licm/InstSunk                  14%
inline/Inlined                  7%
inline/TooCostly                5%
licm/LoadWithLoopInvariantAddressInvalidated  4%
licm/Hoisted                    3%
inline/NeverInline              2%
loop-vectorize/MissedDetails    1%
loop-vectorize/CFGNotUnderstood  1%
slp-vectorizer/NotPossible      1%

[paquette]

Updated patch to reflect the NFC changes I put in to speed up size remarks.

@thegameg, I tried using the DiagnosticInfoIROptimization constructor directly like you suggested, but I don't think that's going to work. It's an abstract class, so it doesn't like it unfortunately. :( I'll look into it in a follow-up. I think it might be a little more invasive than expected.

[paquette]

Forgot to address a review comment; just did that.

[thegameg]

Still LGTM.

[paquette]

Committed in r341588.

Thanks!

https://reviews.llvm.org/rL341588

include/llvm/IR/LegacyPassManagers.h

void populateInheritedAnalysis(PMStack &PMS) {
     for (PMStack::iterator I = PMS.begin(), E = PMS.end();
          I != E; ++I)
       InheritedAnalysis[Index++] = (*I)->getAvailableAnalysis();
   }
 
   /// Set the initial size of the module if the user has specified that they
   /// want remarks for size.
   /// Returns 0 if the remark was not requested.
-  unsigned initSizeRemarkInfo(Module &M);
-
-  /// Emit a remark signifying that the number of IR instructions in the module
-  /// changed.
-  void emitInstrCountChangedRemark(Pass *P, Module &M, unsigned CountBefore);
+  unsigned
+  initSizeRemarkInfo(Module &M,
+                     StringMap<std::pair<unsigned, unsigned>>
+                         &FunctionToInstrCount);
+
+  /// Emits remarks reflecting changes in the IR count of \p M after the pass
+  /// \p P runs. Emits a remark for each change in function IR counts, recorded
+  /// in \p FunctionToInstrCount.
+  ///
+  /// \p FunctionToInstrCount maps the name of a \p Function to a pair. The
+  /// first member of the pair is the IR count of the \p Function before running
+  /// \p P, and the second member is the IR count of the \p Function after
+  /// running \p P.
+  void emitInstrCountChangedRemark(
+      Pass *P, Module &M, unsigned CountBefore,
+      StringMap<std::pair<unsigned, unsigned>>
+          &FunctionToInstrCount);
 
 protected:
   // Top level manager.
   PMTopLevelManager *TPM;
 
   // Collection of pass that are managed by this manager
   SmallVector<Pass *, 16> PassVector;
 

lib/Analysis/CallGraphSCCPass.cpp

if (!PM) {
     CallGraphSCCPass *CGSP = (CallGraphSCCPass*)P;
     if (!CallGraphUpToDate) {
       DevirtualizedCall |= RefreshCallGraph(CurSCC, CG, false);
       CallGraphUpToDate = true;
     }
 
     {
       unsigned InstrCount = 0;
+      StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount;
       bool EmitICRemark = M.shouldEmitInstrCountChangedRemark();
       TimeRegion PassTimer(getPassTimer(CGSP));
       if (EmitICRemark)
-        InstrCount = initSizeRemarkInfo(M);
+        InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount);
       Changed = CGSP->runOnSCC(CurSCC);
 
       // If the pass modified the module, it may have modified the instruction
       // count of the module. Try emitting a remark.
       if (EmitICRemark)
-        emitInstrCountChangedRemark(P, M, InstrCount);
+        emitInstrCountChangedRemark(P, M, InstrCount, FunctionToInstrCount);
     }
 
     // After the CGSCCPass is done, when assertions are enabled, use
     // RefreshCallGraph to verify that the callgraph was correctly updated.
 #ifndef NDEBUG
     if (Changed)
       RefreshCallGraph(CurSCC, CG, true);
 #endif

lib/Analysis/LoopPass.cpp

for (Loop *L : LQ) {
     for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
       LoopPass *P = getContainedPass(Index);
       Changed |= P->doInitialization(L, *this);
     }
   }
 
   // Walk Loops
   unsigned InstrCount = 0;
+  StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount;
   bool EmitICRemark = M.shouldEmitInstrCountChangedRemark();
   while (!LQ.empty()) {
     CurrentLoopDeleted = false;
     CurrentLoop = LQ.back();
 
     // Run all passes on the current Loop.
     for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
       LoopPass *P = getContainedPass(Index);
 
       dumpPassInfo(P, EXECUTION_MSG, ON_LOOP_MSG,
                    CurrentLoop->getHeader()->getName());
       dumpRequiredSet(P);
 
       initializeAnalysisImpl(P);
 
       {
         PassManagerPrettyStackEntry X(P, *CurrentLoop->getHeader());
         TimeRegion PassTimer(getPassTimer(P));
         if (EmitICRemark)
-          InstrCount = initSizeRemarkInfo(M);
+          InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount);
         Changed |= P->runOnLoop(CurrentLoop, *this);
         if (EmitICRemark)
-          emitInstrCountChangedRemark(P, M, InstrCount);
+          emitInstrCountChangedRemark(P, M, InstrCount, FunctionToInstrCount);
       }
 
       if (Changed)
         dumpPassInfo(P, MODIFICATION_MSG, ON_LOOP_MSG,
                      CurrentLoopDeleted ? "<deleted loop>"
                                         : CurrentLoop->getName());
       dumpPreservedSet(P);
 

lib/IR/LegacyPassManager.cpp

bool llvm::isFunctionInPrintList(StringRef FunctionName) {
   return PrintFuncNames.empty() || PrintFuncNames.count(FunctionName);
 }
 /// isPassDebuggingExecutionsOrMore - Return true if -debug-pass=Executions
 /// or higher is specified.
 bool PMDataManager::isPassDebuggingExecutionsOrMore() const {
   return PassDebugging >= Executions;
 }
 
-unsigned PMDataManager::initSizeRemarkInfo(Module &M) {
+unsigned PMDataManager::initSizeRemarkInfo(
+    Module &M, StringMap<std::pair<unsigned, unsigned>> &FunctionToInstrCount) {
   // Only calculate getInstructionCount if the size-info remark is requested.
-  return M.getInstructionCount();
-}
+  unsigned InstrCount = 0;
 
-void PMDataManager::emitInstrCountChangedRemark(Pass *P, Module &M,
-                                                unsigned CountBefore) {
+  // Collect instruction counts for every function. We'll use this to emit
+  // per-function size remarks later.
+  for (Function &F : M) {
+    unsigned FCount = F.getInstructionCount();
+
+    // Insert a record into FunctionToInstrCount keeping track of the current
+    // size of the function as the first member of a pair. Set the second
+    // member to 0; if the function is deleted by the pass, then when we get
+    // here, we'll be able to let the user know that F no longer contributes to
+    // the module.
+    FunctionToInstrCount[F.getName().str()] =
+        std::pair<unsigned, unsigned>(FCount, 0);
+    InstrCount += FCount;
+  }
+  return InstrCount;
+}
+
+void PMDataManager::emitInstrCountChangedRemark(
+    Pass *P, Module &M, unsigned CountBefore,
+    StringMap<std::pair<unsigned, unsigned>> &FunctionToInstrCount) {
   // We need a function containing at least one basic block in order to output
   // remarks. Since it's possible that the first function in the module doesn't
   // actually contain a basic block, we have to go and find one that's suitable
   // for emitting remarks.
   auto It = std::find_if(M.begin(), M.end(),
                          [](const Function &Fn) { return !Fn.empty(); });
 
   // Didn't find a function. Quit.
   if (It == M.end())
     return;
 
   // We found a function containing at least one basic block.
-  Function *F = &*It;
+  Function *SomeFunction = &*It;
 
-  // How many instructions are in the module now?
-  unsigned CountAfter = M.getInstructionCount();
+  // Calculate the module instruction count and function instruction counts
+  // for after the pass ran.
+  unsigned CountAfter = 0;
+  for (Function &F : M) {
+    // Update the total module count.
+    unsigned FnSize = F.getInstructionCount();
+    CountAfter += FnSize;
+    auto It = FunctionToInstrCount.find(F.getName());
+
+    // If we created a new function, then we need to add it to the map and say
+    // that it changed from 0 instructions to FnSize.
+    if (It == FunctionToInstrCount.end()) {
+      std::pair<unsigned, unsigned> ChangePair(0, FnSize);
+      FunctionToInstrCount.insert(
+          std::make_pair(F.getName().str(), ChangePair));
+      continue;
+    }
+    // Insert the new function size into the second member of the pair. This
+    // tells us whether or not this function changed in size.
+    It->second.second = FnSize;
+  }
 
   // If there was no change, don't emit a remark.
   if (CountBefore == CountAfter)
     return;
 
   // If it's a pass manager, don't emit a remark. (This hinges on the assumption
   // that the only passes that return non-null with getAsPMDataManager are pass
   // managers.) The reason we have to do this is to avoid emitting remarks for
   // CGSCC passes.
   if (P->getAsPMDataManager())
     return;
 
   // Compute a possibly negative delta between the instruction count before
   // running P, and after running P.
   int64_t Delta =
       static_cast<int64_t>(CountAfter) - static_cast<int64_t>(CountBefore);
 
-  BasicBlock &BB = *F->begin();
+  BasicBlock &BB = *SomeFunction->begin();
   OptimizationRemarkAnalysis R("size-info", "IRSizeChange",
                                DiagnosticLocation(), &BB);
   // FIXME: Move ore namespace to DiagnosticInfo so that we can use it. This
   // would let us use NV instead of DiagnosticInfoOptimizationBase::Argument.
   R << DiagnosticInfoOptimizationBase::Argument("Pass", P->getPassName())
     << ": IR instruction count changed from "
     << DiagnosticInfoOptimizationBase::Argument("IRInstrsBefore", CountBefore)
     << " to "
     << DiagnosticInfoOptimizationBase::Argument("IRInstrsAfter", CountAfter)
     << "; Delta: "
     << DiagnosticInfoOptimizationBase::Argument("DeltaInstrCount", Delta);
-  F->getContext().diagnose(R); // Not using ORE for layering reasons.
+  SomeFunction->getContext().diagnose(R); // Not using ORE for layering reasons.
+  // Emit per-function size change remarks separately.
+  // FIXME: We shouldn't use BB for the location here. Unfortunately, because
+  // the function that we're looking at could have been deleted, we can't use
+  // it for the source location. We *want* remarks when a function is deleted
+  // though, so we're kind of stuck here as is. (This remark, along with the
+  // whole-module size change remarks really ought not to have source locations
+  // at all.)
+  for (auto &Fname : FunctionToInstrCount.keys()) {
+    OptimizationRemarkAnalysis FR("size-info", "FunctionIRSizeChange",
+                                  DiagnosticLocation(), &BB);
+    unsigned FnCountBefore, FnCountAfter;
+    std::tie(FnCountBefore, FnCountAfter) = FunctionToInstrCount[Fname];
+    int64_t FnDelta = static_cast<int64_t>(FnCountAfter) -
+                      static_cast<int64_t>(FnCountBefore);
+
+    // If there was a change in the function, emit a remark. Otherwise, do
+    // nothing.
+    if (FnDelta != 0) {
+      FR << DiagnosticInfoOptimizationBase::Argument("Pass", P->getPassName())
+         << ": Function: "
+         << DiagnosticInfoOptimizationBase::Argument("Function", Fname)
+         << ": IR instruction count changed from "
+         << DiagnosticInfoOptimizationBase::Argument("IRInstrsBefore",
+                                                     FnCountBefore)
+         << " to "
+         << DiagnosticInfoOptimizationBase::Argument("IRInstrsAfter",
+                                                     FnCountAfter)
+         << "; Delta: "
+         << DiagnosticInfoOptimizationBase::Argument("DeltaInstrCount",
+                                                     FnDelta);
+      SomeFunction->getContext().diagnose(FR);
+    }
+  }
 }
 
 void PassManagerPrettyStackEntry::print(raw_ostream &OS) const {
   if (!V && !M)
     OS << "Releasing pass '";
   else
     OS << "Running pass '";
 

 bool BBPassManager::runOnFunction(Function &F) {
   if (F.isDeclaration())
     return false;
 
   bool Changed = doInitialization(F);
   Module &M = *F.getParent();
 
   unsigned InstrCount = 0;
+  StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount;
+
   bool EmitICRemark = M.shouldEmitInstrCountChangedRemark();
   for (BasicBlock &BB : F)
     for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
       BasicBlockPass *BP = getContainedPass(Index);
       bool LocalChanged = false;
 
       dumpPassInfo(BP, EXECUTION_MSG, ON_BASICBLOCK_MSG, BB.getName());
       dumpRequiredSet(BP);
 
       initializeAnalysisImpl(BP);
 
       {
         // If the pass crashes, remember this.
         PassManagerPrettyStackEntry X(BP, BB);
         TimeRegion PassTimer(getPassTimer(BP));
         if (EmitICRemark)
-          InstrCount = initSizeRemarkInfo(M);
+          InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount);
         LocalChanged |= BP->runOnBasicBlock(BB);
         if (EmitICRemark)
-          emitInstrCountChangedRemark(BP, M, InstrCount);
+          emitInstrCountChangedRemark(BP, M, InstrCount, FunctionToInstrCount);
       }
 
       Changed |= LocalChanged;
       if (LocalChanged)
         dumpPassInfo(BP, MODIFICATION_MSG, ON_BASICBLOCK_MSG,
                      BB.getName());
       dumpPreservedSet(BP);
       dumpUsedSet(BP);
if (F.isDeclaration())
     return false;
 
   bool Changed = false;
   Module &M = *F.getParent();
   // Collect inherited analysis from Module level pass manager.
   populateInheritedAnalysis(TPM->activeStack);
 
   unsigned InstrCount = 0;
+  StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount;
   bool EmitICRemark = M.shouldEmitInstrCountChangedRemark();
   for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
     FunctionPass *FP = getContainedPass(Index);
     bool LocalChanged = false;
 
     dumpPassInfo(FP, EXECUTION_MSG, ON_FUNCTION_MSG, F.getName());
     dumpRequiredSet(FP);
 
     initializeAnalysisImpl(FP);
 
     {
       PassManagerPrettyStackEntry X(FP, F);
       TimeRegion PassTimer(getPassTimer(FP));
       if (EmitICRemark)
-        InstrCount = initSizeRemarkInfo(M);
+        InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount);
       LocalChanged |= FP->runOnFunction(F);
       if (EmitICRemark)
-        emitInstrCountChangedRemark(FP, M, InstrCount);
+        emitInstrCountChangedRemark(FP, M, InstrCount, FunctionToInstrCount);
     }
 
     Changed |= LocalChanged;
     if (LocalChanged)
       dumpPassInfo(FP, MODIFICATION_MSG, ON_FUNCTION_MSG, F.getName());
     dumpPreservedSet(FP);
     dumpUsedSet(FP);
 
for (auto &OnTheFlyManager : OnTheFlyManagers) {
     Changed |= FPP->doInitialization(M);
   }
 
   // Initialize module passes
   for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index)
     Changed |= getContainedPass(Index)->doInitialization(M);
 
   unsigned InstrCount = 0;
+  StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount;
   bool EmitICRemark = M.shouldEmitInstrCountChangedRemark();
   for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
     ModulePass *MP = getContainedPass(Index);
     bool LocalChanged = false;
 
     dumpPassInfo(MP, EXECUTION_MSG, ON_MODULE_MSG, M.getModuleIdentifier());
     dumpRequiredSet(MP);
 
     initializeAnalysisImpl(MP);
 
     {
       PassManagerPrettyStackEntry X(MP, M);
       TimeRegion PassTimer(getPassTimer(MP));
 
       if (EmitICRemark)
-        InstrCount = initSizeRemarkInfo(M);
+        InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount);
       LocalChanged |= MP->runOnModule(M);
       if (EmitICRemark)
-        emitInstrCountChangedRemark(MP, M, InstrCount);
+        emitInstrCountChangedRemark(MP, M, InstrCount, FunctionToInstrCount);
     }
 
     Changed |= LocalChanged;
     if (LocalChanged)
       dumpPassInfo(MP, MODIFICATION_MSG, ON_MODULE_MSG,
                    M.getModuleIdentifier());
     dumpPreservedSet(MP);
     dumpUsedSet(MP);

test/Other/size-remarks.ll

 ; Ensure that IR count remarks in the legacy pass manager work.
 ; What this test should check for:
-; * Positive, nonzero sizes before/after
+; * Positive, nonzero sizes before/after for whole-module remarks
+;   (It's okay to have nonzero sizes in per-function remarks, since a function
+;    can be created/destroyed by a pass.)
 ; * Nonzero deltas
 ; * Sizes are being tracked properly across multiple remarks. E.g, if we have
 ;     original_count_1, final_count_1, and
 ;     original_count_2, final_count_2,
 ;  Then original_count_2 == final_count_1.
 
 ; For these remarks, the "function" field in the YAML file doesn't matter.
 ; Each of the testcases work by combining the output remarks with the
 ; optimization record emit using -pass-remarks-output. This is done to prevent
 ; test flakiness wrt instruction counts, but also ensure that the output values
 ; are equivalent in both outputs.
 
 ; RUN: opt < %s -inline -pass-remarks-analysis='size-info' \
 ; RUN: -pass-remarks-output=%t.yaml -S -o /dev/null 2> %t; \
 ; RUN: cat %t %t.yaml | FileCheck %s -check-prefix=CGSCC
 ; CGSCC: remark: <unknown>:0:0: Function Integration/Inlining:
 ; CGSCC-SAME: IR instruction count changed from
 ; CGSCC-SAME: [[ORIG:[1-9][0-9]*]] to [[FINAL:[1-9][0-9]*]];
 ; CGSCC-SAME: Delta: [[DELTA:-?[1-9][0-9]*]]
+; CGSCC-NEXT: remark: <unknown>:0:0: Function Integration/Inlining:
+; CGSCC-SAME: Function: bar: IR instruction count changed from
+; CGSCC-SAME: [[ORIGFN:[1-9][0-9]*]] to [[FINALFN:[0-9][0-9]*]];
+; CGSCC-SAME: Delta: [[DELTAFN:-?[1-9][0-9]*]]
+
 ; CGSCC: --- !Analysis
 ; CGSCC-NEXT: Pass:            size-info
 ; CGSCC-NEXT: Name:            IRSizeChange
 ; CGSCC-NEXT: Function:
-; CGSCC-NEXT: Args:            
+; CGSCC-NEXT: Args:
 ; CGSCC-NEXT:  - Pass:            Function Integration/Inlining
 ; CGSCC-NEXT:  - String:          ': IR instruction count changed from '
 ; CGSCC-NEXT:  - IRInstrsBefore:  '[[ORIG]]'
 ; CGSCC-NEXT:  - String:          ' to '
 ; CGSCC-NEXT:  - IRInstrsAfter:   '[[FINAL]]'
 ; CGSCC-NEXT:  - String:          '; Delta: '
 ; CGSCC-NEXT:  - DeltaInstrCount: '[[DELTA]]'
+; CGSCC-DAG: --- !Analysis
+; CGSCC-NEXT: Pass:            size-info
+; CGSCC-NEXT: Name:            FunctionIRSizeChange
+; CGSCC-NEXT: Function:
+; CGSCC-NEXT: Args:
+; CGSCC-NEXT:   - Pass:            Function Integration/Inlining
+; CGSCC-NEXT:   - String:          ': Function: '
+; CGSCC-NEXT:   - Function:        bar
+; CGSCC-NEXT:   - String:          ': IR instruction count changed from '
+; CGSCC-NEXT:   - IRInstrsBefore:  '[[ORIGFN]]'
+; CGSCC-NEXT:   - String:          ' to '
+; CGSCC-NEXT:   - IRInstrsAfter:   '[[FINALFN]]'
+; CGSCC-NEXT:   - String:          '; Delta: '
+; CGSCC-NEXT:   - DeltaInstrCount: '[[DELTAFN]]'
+; CGSCC-NEXT: ...
 
 ; RUN: opt < %s -instcombine -pass-remarks-analysis='size-info' \
 ; RUN:-pass-remarks-output=%t.yaml -S -o /dev/null 2> %t; \
 ; RUN: cat %t %t.yaml | FileCheck %s -check-prefix=FUNC
 ; FUNC: remark: <unknown>:0:0: Combine redundant instructions:
 ; FUNC-SAME: IR instruction count changed from
-; FUNC-SAME: [[SIZE1:[1-9][0-9]*]] to [[SIZE2:[1-9][0-9]*]];
+; FUNC-SAME: [[SIZE1:[1-9][0-9]*]] to [[SIZE2:[0-9][0-9]*]];
 ; FUNC-SAME: Delta: [[DELTA1:-?[1-9][0-9]*]]
+; FUNC-NEXT: remark: <unknown>:0:0: Combine redundant instructions: Function:
+; FUNC-SAME: foo: IR instruction count changed from
+; FUNC-SAME: [[FOOSIZE1:[1-9][0-9]*]] to [[FOOSIZE2:[0-9][0-9]*]];
+; FUNC-SAME: Delta: [[DELTAFOO:-?[1-9][0-9]*]]
 ; FUNC-NEXT: remark: <unknown>:0:0: Combine redundant instructions:
 ; FUNC-SAME: IR instruction count changed from
 ; FUNC-SAME: [[SIZE2]] to [[SIZE3:[1-9][0-9]*]];
 ; FUNC-SAME: Delta: [[DELTA2:-?[1-9][0-9]*]]
+; FUNC-NEXT: remark: <unknown>:0:0: Combine redundant instructions: Function:
+; FUNC-SAME: bar: IR instruction count changed from
+; FUNC-SAME: [[BARSIZE1:[1-9][0-9]*]] to [[BARSIZE2:[0-9][0-9]*]];
+; FUNC-SAME: Delta: [[DELTABAR:-?[1-9][0-9]*]]
 ; FUNC: --- !Analysis
 ; FUNC-NEXT: Pass:            size-info
 ; FUNC-NEXT: Name:            IRSizeChange
 ; FUNC-NEXT: Function:
-; FUNC-NEXT: Args:            
+; FUNC-NEXT: Args:
 ; FUNC-NEXT:  - Pass:            Combine redundant instructions
 ; FUNC-NEXT:  - String:          ': IR instruction count changed from '
 ; FUNC-NEXT:  - IRInstrsBefore:  '[[SIZE1]]'
 ; FUNC-NEXT:  - String:          ' to '
 ; FUNC-NEXT:  - IRInstrsAfter:   '[[SIZE2]]'
 ; FUNC-NEXT:  - String:          '; Delta: '
 ; FUNC-NEXT:  - DeltaInstrCount: '[[DELTA1]]'
+; FUNC-DAG: --- !Analysis
+; FUNC-NEXT: Pass:            size-info
+; FUNC-NEXT: Name:            FunctionIRSizeChange
+; FUNC-NEXT: Function:
+; FUNC-NEXT: Args:
+; FUNC-NEXT:   - Pass:            Combine redundant instructions
+; FUNC-NEXT:   - String:          ': Function: '
+; FUNC-NEXT:   - Function:        foo
+; FUNC-NEXT:   - String:          ': IR instruction count changed from '
+; FUNC-NEXT:   - IRInstrsBefore:  '[[FOOSIZE1]]'
+; FUNC-NEXT:   - String:          ' to '
+; FUNC-NEXT:   - IRInstrsAfter:   '[[FOOSIZE2]]'
+; FUNC-NEXT:   - String:          '; Delta: '
+; FUNC-NEXT:   - DeltaInstrCount: '[[DELTAFOO]]'
 ; FUNC: --- !Analysis
 ; FUNC-NEXT: Pass:            size-info
 ; FUNC-NEXT: Name:            IRSizeChange
 ; FUNC-NEXT: Function:
-; FUNC-NEXT: Args:            
+; FUNC-NEXT: Args:
 ; FUNC-NEXT:   - Pass:            Combine redundant instructions
 ; FUNC-NEXT:   - String:          ': IR instruction count changed from '
 ; FUNC-NEXT:   - IRInstrsBefore:  '[[SIZE2]]'
 ; FUNC-NEXT:   - String:          ' to '
 ; FUNC-NEXT:   - IRInstrsAfter:   '[[SIZE3]]'
 ; FUNC-NEXT:   - String:          '; Delta: '
 ; FUNC-NEXT:   - DeltaInstrCount: '[[DELTA2]]'
+; FUNC-DAG: --- !Analysis
+; FUNC-NEXT: Pass:            size-info
+; FUNC-NEXT: Name:            FunctionIRSizeChange
+; FUNC-NEXT: Function:
+; FUNC-NEXT: Args:
+; FUNC-NEXT:   - Pass:            Combine redundant instructions
+; FUNC-NEXT:   - String:          ': Function: '
+; FUNC-NEXT:   - Function:        bar
+; FUNC-NEXT:   - String:          ': IR instruction count changed from '
+; FUNC-NEXT:   - IRInstrsBefore:  '[[BARSIZE1]]'
+; FUNC-NEXT:   - String:          ' to '
+; FUNC-NEXT:   - IRInstrsAfter:   '[[BARSIZE2]]'
+; FUNC-NEXT:   - String:          '; Delta: '
+; FUNC-NEXT:   - DeltaInstrCount: '[[DELTABAR]]'
 
 ; RUN: opt < %s -globaldce -pass-remarks-analysis='size-info' \
 ; RUN: -pass-remarks-output=%t.yaml -S -o /dev/null 2> %t; \
 ; RUN: cat %t %t.yaml | FileCheck %s -check-prefix=MODULE
 ; MODULE: remark:
 ; MODULE-SAME: Dead Global Elimination:
 ; MODULE-SAME: IR instruction count changed from
 ; MODULE-SAME: [[ORIG:[1-9][0-9]*]] to [[FINAL:[1-9][0-9]*]];
 ; MODULE-SAME: Delta: [[DELTA:-?[1-9][0-9]*]]
+; MODULE-NEXT: remark:
+; MODULE-SAME: Dead Global Elimination: Function: pluto:
+; MODULE-SAME: IR instruction count changed from [[ORIGFN:[1-9][0-9]*]] to
+; MODULE-SAME: [[FINALFN:[0-9][0-9]*]]; Delta: [[DELTAFN:-?[1-9][0-9]*]]
 ; MODULE: --- !Analysis
 ; MODULE-NEXT: Pass:            size-info
 ; MODULE-NEXT: Name:            IRSizeChange
 ; MODULE-NEXT: Function:
-; MODULE-NEXT: Args:            
+; MODULE-NEXT: Args:
 ; MODULE-NEXT:   - Pass:            Dead Global Elimination
 ; MODULE-NEXT:   - String:          ': IR instruction count changed from '
 ; MODULE-NEXT:   - IRInstrsBefore:  '[[ORIG]]'
 ; MODULE-NEXT:   - String:          ' to '
 ; MODULE-NEXT:   - IRInstrsAfter:   '[[FINAL]]'
 ; MODULE-NEXT:   - String:          '; Delta: '
 ; MODULE-NEXT:   - DeltaInstrCount: '[[DELTA]]'
+; MODULE-DAG: --- !Analysis
+; MODULE-NEXT: Pass:            size-info
+; MODULE-NEXT: Name:            FunctionIRSizeChange
+; MODULE-NEXT: Function:
+; MODULE-NEXT: Args:
+; MODULE-NEXT:   - Pass:            Dead Global Elimination
+; MODULE-NEXT:   - String:          ': Function: '
+; MODULE-NEXT:   - Function:        pluto
+; MODULE-NEXT:   - String:          ': IR instruction count changed from '
+; MODULE-NEXT:   - IRInstrsBefore:  '[[ORIGFN]]'
+; MODULE-NEXT:   - String:          ' to '
+; MODULE-NEXT:   - IRInstrsAfter:   '[[FINALFN]]'
+; MODULE-NEXT:   - String:          '; Delta: '
+; MODULE-NEXT:   - DeltaInstrCount: '[[DELTAFN]]'
 
 ; RUN: opt < %s -dce -pass-remarks-analysis='size-info' \
 ; RUN: -pass-remarks-output=%t.yaml -S -o /dev/null 2> %t; \
 ; RUN: cat %t %t.yaml | FileCheck %s -check-prefix=BB
 ; BB: remark: <unknown>:0:0: Dead Code Elimination:
 ; BB-SAME: IR instruction count changed from
 ; BB-SAME: [[ORIG:[1-9][0-9]*]] to [[FINAL:[1-9][0-9]*]];
 ; BB-SAME: Delta: [[DELTA:-?[1-9][0-9]*]]
+; BB-NEXT: remark: <unknown>:0:0: Dead Code Elimination: Function: bar:
+; BB-SAME: IR instruction count changed from [[ORIGFN:[1-9][0-9]*]] to
+; BB-SAME: [[FINALFN:[0-9][0-9]*]]; Delta: [[DELTAFN:-?[1-9][0-9]*]]
 ; BB: --- !Analysis
 ; BB-NEXT: Pass:            size-info
 ; BB-NEXT: Name:            IRSizeChange
 ; BB-NEXT: Function:
 ; BB-NEXT: Args:            
 ; BB-NEXT:   - Pass:            Dead Code Elimination
 ; BB-NEXT:   - String:          ': IR instruction count changed from '
 ; BB-NEXT:   - IRInstrsBefore:  '[[ORIG]]'
 ; BB-NEXT:   - String:          ' to '
 ; BB-NEXT:   - IRInstrsAfter:   '[[FINAL]]'
 ; BB-NEXT:   - String:          '; Delta: '
 ; BB-NEXT:   - DeltaInstrCount: '[[DELTA]]'
+; BB-DAG: --- !Analysis
+; BB-NEXT: Pass:            size-info
+; BB-NEXT: Name:            FunctionIRSizeChange
+; BB-NEXT: Function:
+; BB-NEXT: Args:
+; BB-NEXT:   - Pass:            Dead Code Elimination
+; BB-NEXT:   - String:          ': Function: '
+; BB-NEXT:   - Function:        bar
+; BB-NEXT:   - String:          ': IR instruction count changed from '
+; BB-NEXT:   - IRInstrsBefore:  '[[ORIGFN]]'
+; BB-NEXT:   - String:          ' to '
+; BB-NEXT:   - IRInstrsAfter:   '[[FINALFN]]'
+; BB-NEXT:   - String:          '; Delta: '
+; BB-NEXT:   - DeltaInstrCount: '[[DELTAFN]]'
 
 ; RUN: opt < %s -loop-unroll -pass-remarks-analysis='size-info' \
 ; RUN: -pass-remarks-output=%t.yaml -S -o /dev/null 2> %t; \
 ; RUN: cat %t %t.yaml | FileCheck %s -check-prefix=LOOP
 ; LOOP: remark: <unknown>:0:0: Unroll loops:
 ; LOOP-SAME: IR instruction count changed from
 ; LOOP-SAME: [[ORIG:[1-9][0-9]*]] to [[FINAL:[1-9][0-9]*]];
 ; LOOP-SAME: Delta: [[DELTA:-?[1-9][0-9]*]]
+; LOOP-NEXT: remark: <unknown>:0:0: Unroll loops: Function: bar:
+; LOOP-SAME: IR instruction count changed from [[ORIGFN:[1-9][0-9]*]]
+; LOOP-SAME: to [[FINALFN:[0-9][0-9]*]];
+; Since bar is the only function containing a loop, its delta must be identical
+; to the whole module remark's delta.
+; LOOP-SAME: Delta: [[DELTA]]
 ; LOOP: --- !Analysis
 ; LOOP-NEXT: Pass:            size-info
 ; LOOP-NEXT: Name:            IRSizeChange
 ; LOOP-NEXT: Function:
-; LOOP-NEXT: Args:            
+; LOOP-NEXT: Args:
 ; LOOP-DAG:   - Pass:            Unroll loops
 ; LOOP-NEXT:   - String:          ': IR instruction count changed from '
 ; LOOP-NEXT:   - IRInstrsBefore:  '[[ORIG]]'
 ; LOOP-NEXT:   - String:          ' to '
 ; LOOP-NEXT:   - IRInstrsAfter:   '[[FINAL]]'
 ; LOOP-NEXT:   - String:          '; Delta: '
 ; LOOP-NEXT:   - DeltaInstrCount: '[[DELTA]]'
+; LOOP-DAG: --- !Analysis
+; LOOP-NEXT: Pass:            size-info
+; LOOP-NEXT: Name:            FunctionIRSizeChange
+; LOOP-NEXT: Function:
+; LOOP-NEXT: Args:
+; LOOP-NEXT:   - Pass:            Unroll loops
+; LOOP-NEXT:   - String:          ': Function: '
+; LOOP-NEXT:   - Function:        bar
+; LOOP-NEXT:   - String:          ': IR instruction count changed from '
+; LOOP-NEXT:   - IRInstrsBefore:  '[[ORIGFN]]'
+; LOOP-NEXT:   - String:          ' to '
+; LOOP-NEXT:   - IRInstrsAfter:   '[[FINALFN]]'
+; LOOP-NEXT:   - String:          '; Delta: '
+; LOOP-NEXT:   - DeltaInstrCount: '[[DELTA]]'
 declare i1 ()* @boop()
 
 define internal i1 @pluto() {
   %F = call i1 ()* () @boop( )
   %c = icmp eq i1 ()* %F, @pluto
   ret i1 %c
 }