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

175

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

241

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);
+  unsigned initSizeRemarkInfo(
+      Module &M,
+      StringMap<std::pair<unsigned, unsigned>> &FunctionToInstrCount);
 
   /// Emit a remark signifying that the number of IR instructions in the module
   /// changed.
   /// \p F is optionally passed by passes which run on Functions, and thus
   /// always know whether or not a non-empty function is available.
-  void emitInstrCountChangedRemark(Pass *P, Module &M, int64_t Delta,
-                                   unsigned CountBefore, Function *F = nullptr);
+  ///
+  /// \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, int64_t Delta, unsigned CountBefore,
+      StringMap<std::pair<unsigned, unsigned>> &FunctionToInstrCount,
+      Function *F = nullptr);
 
 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, SCCCount = 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 (EmitICRemark) {
         // FIXME: Add getInstructionCount to CallGraphSCC.
         SCCCount = M.getInstructionCount();
         // Is there a difference in the number of instructions in the module?
         if (SCCCount != InstrCount) {
           // Yep. Emit a remark and update InstrCount.
           int64_t Delta =
               static_cast<int64_t>(SCCCount) - static_cast<int64_t>(InstrCount);
-          emitInstrCountChangedRemark(P, M, Delta, InstrCount);
+          emitInstrCountChangedRemark(P, M, Delta, InstrCount,
+                                      FunctionToInstrCount);
           InstrCount = SCCCount;
         }
       }
     }
 
     // After the CGSCCPass is done, when assertions are enabled, use
     // RefreshCallGraph to verify that the callgraph was correctly updated.
 #ifndef NDEBUG

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, FunctionSize = 0;
+  StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount;
   bool EmitICRemark = M.shouldEmitInstrCountChangedRemark();
   // Collect the initial size of the module and the function we're looking at.
   if (EmitICRemark) {
-    InstrCount = initSizeRemarkInfo(M);
+    InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount);
     FunctionSize = F.getInstructionCount();
   }
   while (!LQ.empty()) {
     CurrentLoopDeleted = false;
     CurrentLoop = LQ.back();
 
     // Run all passes on the current Loop.
     for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
         Changed |= P->runOnLoop(CurrentLoop, *this);
         if (EmitICRemark) {
           unsigned NewSize = F.getInstructionCount();
           // Update the size of the function, emit a remark, and update the
           // size of the module.
           if (NewSize != FunctionSize) {
             int64_t Delta = static_cast<int64_t>(NewSize) -
                             static_cast<int64_t>(FunctionSize);
-            emitInstrCountChangedRemark(P, M, Delta, InstrCount, &F);
+            emitInstrCountChangedRemark(P, M, Delta, InstrCount,
+                                        FunctionToInstrCount, &F);
             InstrCount = static_cast<int64_t>(InstrCount) + Delta;
             FunctionSize = NewSize;
           }
         }
       }
 
       if (Changed)
         dumpPassInfo(P, MODIFICATION_MSG, ON_LOOP_MSG,

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,
-                                                int64_t Delta,
-                                                unsigned CountBefore,
-                                                Function *F) {
+  // 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, int64_t Delta, unsigned CountBefore,
+    StringMap<std::pair<unsigned, unsigned>> &FunctionToInstrCount,
   // 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;
 
   // Set to true if this isn't a module pass or CGSCC pass.
   bool CouldOnlyImpactOneFunction = (F != nullptr);
 
+  // Helper lambda that updates the changes to the size of some function.
+  auto UpdateFunctionChanges =
+      [&FunctionToInstrCount](Function &MaybeChangedFn) {
+        // Update the total module count.
+        unsigned FnSize = MaybeChangedFn.getInstructionCount();
+        auto It = FunctionToInstrCount.find(MaybeChangedFn.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()) {
+          FunctionToInstrCount[MaybeChangedFn] =
+              std::pair<unsigned, unsigned>(0, FnSize);
+          return;
+        }
+        // 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;
+      };
+
+  // We need to initially update all of the function sizes.
+  // If no function was passed in, then we're either a module pass or an
+  // CGSCC pass.
+  if (!CouldOnlyImpactOneFunction)
+    std::for_each(M.begin(), M.end(), UpdateFunctionChanges);
+  else
+    UpdateFunctionChanges(*F);
+
   // Do we have a function we can use to emit a remark?
   if (!CouldOnlyImpactOneFunction) {
     // 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.
     F = &*It;
   }
   int64_t CountAfter = static_cast<int64_t>(CountBefore) + Delta;
   BasicBlock &BB = *F->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.
+
+  // Emit per-function size change remarks separately.
+  std::string PassName = P->getPassName().str();
+
+  // Helper lambda that emits a remark when the size of a function has changed.
+  auto EmitFunctionSizeChangedRemark = [&FunctionToInstrCount, &F, &BB,
+                                        &PassName](const std::string &Fname) {
+    unsigned FnCountBefore, FnCountAfter;
+    std::pair<unsigned, unsigned> &Change = FunctionToInstrCount[Fname];
+    std::tie(FnCountBefore, FnCountAfter) = Change;
+    int64_t FnDelta = static_cast<int64_t>(FnCountAfter) -
+                      static_cast<int64_t>(FnCountBefore);
+
+    if (FnDelta == 0)
+      return;
+
+    // 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.)
+    OptimizationRemarkAnalysis FR("size-info", "FunctionIRSizeChange",
+                                  DiagnosticLocation(), &BB);
+    FR << DiagnosticInfoOptimizationBase::Argument("Pass", PassName)
+       << ": Function: "
+       << DiagnosticInfoOptimizationBase::Argument("Function", Fname)
+       << ": IR instruction count changed from "
+       << DiagnosticInfoOptimizationBase::Argument("IRInstrsBefore",
+                                                   FnCountBefore)
+       << " to "
+       << DiagnosticInfoOptimizationBase::Argument("IRInstrsAfter",
+                                                   FnCountAfter)
+       << "; Delta: "
+       << DiagnosticInfoOptimizationBase::Argument("DeltaInstrCount", FnDelta);
+    F->getContext().diagnose(FR);
+
+    // Update the function size.
+    Change.first = FnCountAfter;
+  };
+
+  // Are we looking at more than one function? If so, emit remarks for all of
+  // the functions in the module. Otherwise, only emit one remark.
+  if (!CouldOnlyImpactOneFunction)
+    std::for_each(FunctionToInstrCount.keys().begin(),
+                  FunctionToInstrCount.keys().end(),
+                  EmitFunctionSizeChangedRemark);
+  else
+    EmitFunctionSizeChangedRemark(F->getName().str());
 }
 
 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, BBSize = 0;
+  StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount;
   bool EmitICRemark = M.shouldEmitInstrCountChangedRemark();
   if (EmitICRemark)
-    InstrCount = initSizeRemarkInfo(M);
+    InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount);
 
   for (BasicBlock &BB : F) {
     // Collect the initial size of the basic block.
     if (EmitICRemark)
       BBSize = BB.size();
     for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
       BasicBlockPass *BP = getContainedPass(Index);
       bool LocalChanged = false;
for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
         LocalChanged |= BP->runOnBasicBlock(BB);
         if (EmitICRemark) {
           unsigned NewSize = BB.size();
           // Update the size of the basic block, emit a remark, and update the
           // size of the module.
           if (NewSize != BBSize) {
             int64_t Delta =
                 static_cast<int64_t>(NewSize) - static_cast<int64_t>(BBSize);
-            emitInstrCountChangedRemark(BP, M, Delta, InstrCount, &F);
+            emitInstrCountChangedRemark(BP, M, Delta, InstrCount,
+                                        FunctionToInstrCount, &F);
             InstrCount = static_cast<int64_t>(InstrCount) + Delta;
             BBSize = NewSize;
           }
         }
       }
 
       Changed |= LocalChanged;
       if (LocalChanged)
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, FunctionSize = 0;
+  StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount;
   bool EmitICRemark = M.shouldEmitInstrCountChangedRemark();
   // Collect the initial size of the module.
   if (EmitICRemark) {
-    InstrCount = initSizeRemarkInfo(M);
+    InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount);
     FunctionSize = F.getInstructionCount();
   }
 
   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));
       LocalChanged |= FP->runOnFunction(F);
       if (EmitICRemark) {
         unsigned NewSize = F.getInstructionCount();
 
         // Update the size of the function, emit a remark, and update the size
         // of the module.
         if (NewSize != FunctionSize) {
           int64_t Delta = static_cast<int64_t>(NewSize) -
                           static_cast<int64_t>(FunctionSize);
-          emitInstrCountChangedRemark(FP, M, Delta, InstrCount, &F);
+          emitInstrCountChangedRemark(FP, M, Delta, InstrCount,
+                                      FunctionToInstrCount, &F);
           InstrCount = static_cast<int64_t>(InstrCount) + Delta;
           FunctionSize = NewSize;
         }
       }
     }
 
     Changed |= LocalChanged;
     if (LocalChanged)
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, ModuleCount = 0;
+  StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount;
   bool EmitICRemark = M.shouldEmitInstrCountChangedRemark();
   // Collect the initial size of the module.
   if (EmitICRemark) {
-    InstrCount = initSizeRemarkInfo(M);
+    InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount);
     ModuleCount = InstrCount;
   }
 
   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));
 
       LocalChanged |= MP->runOnModule(M);
       if (EmitICRemark) {
         // Update the size of the module.
         ModuleCount = M.getInstructionCount();
         if (ModuleCount != InstrCount) {
           int64_t Delta = static_cast<int64_t>(ModuleCount) -
                           static_cast<int64_t>(InstrCount);
-          emitInstrCountChangedRemark(MP, M, Delta, InstrCount);
+          emitInstrCountChangedRemark(MP, M, Delta, InstrCount,
+                                      FunctionToInstrCount);
           InstrCount = ModuleCount;
         }
       }
     }
 
     Changed |= LocalChanged;
     if (LocalChanged)
       dumpPassInfo(MP, MODIFICATION_MSG, ON_MODULE_MSG,

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-NEXT: ---
 ; CGSCC-DAG: !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-NEXT: ---
 ; FUNC-DAG: !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-NEXT: ---
 ; MODULE-DAG: !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-NEXT: ---
 ; BB-DAG: !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-NEXT: ---
 ; LOOP-DAG: !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
 }