Add remarks describing when a pass changes the IR instruction count of a module

[paquette]

Summary

This patch adds a remark which tells the user when a pass changes the number of IR instructions in a module. It can be enabled by using -Rpass-analysis=size-info. The point of this is to make it easier to collect statistics on how passes modify programs in terms of code size. This is similar in concept to timing reports, but using a remark-based interface makes it easy to diff changes over multiple compilations of the same program. By adding functionality like this, we can see

• Which passes impact code size the most
• How passes impact code size at different optimization levels
• Which pass might have contributed the most to an overall code size regression

The patch lives in the legacy pass manager, but since it's simply emitting remarks, it shouldn't be too difficult to adapt the functionality to the new pass manager as well. This can also be adapted to handle MachineInstr counts in the later Machine* passes.

[paquette]

Accidentally added some useless cruft in CGSCCPassManager.h in the first diff. Removed it.

[davide]

Thanks for this, I think it's going to be a useful feature (in some form), as we need to track code size more effectively.
I have some minor comments inline, and Chandler should take a look as well as he fought many battles in the PM area.

lib/IR/LegacyPassManager.cpp

167–197

This doesn't really belong to PMDataManager, if we want something like this it could probably live in Module.

I'm also slightly concerned as this seems to recompute the number of instruction for the whole module every time you run a function pass.
If your TU gets large (e.g. LTO) the overhead will be substantial.
We might strive a more incremental approach, but it's not immediately clear to me how (I'll think about it)

183–184

I'm not sure I understand this one, can you please give an example?

188

we have an early return, so maybe this is redundant. I'm fine either way.

1587

opt-remarks is a function pass and here you're considering as unit of IR the whole module. I think the function pass manager *should* only operate on functions. This bit seems a little odd, to me.

I'd love to hear @chandlerc's thoughts on this,

[davide]

Also, side note, analyses aren't really supposed to change the IR (at least this is the guiding principle) so you might just skip them as well.
It needs a bunch more tests, the one you have only covers the Module pass manager, Thanks again for working on this!

[anemet]

lib/IR/LegacyPassManager.cpp

1587

This is not using the ORE pass for layering reasons. Instead, it works directly with the LLVMContext::diagnose interface.

[paquette]

lib/IR/LegacyPassManager.cpp

167–197

If we only keep track of deltas, then we might be able to do better. Then the question is how much the actual size of the module at every step matters.

For example, if a function pass modifies the size of the program, then we know how many instructions it changed simply by getting the size of the function it acted on before and after the pass. We can then emit a remark with that delta. That would still give us a measure of how much passes change code size. You would still be in trouble with module passes, but it'd at least reduce the overhead for FunctionPasses and their ilk.

183–184

Only pass managers return non-null on getAsPMDataManager. Thus, we can tell whether or not a pass is a pass manager by checking this. It's also used in the same way later in the file in the TimingInfo class. I should probably elaborate more in the comment as well.

It seems more reasonable to use the PassKind that each pass carries around. However, that doesn't work for the inliner's pass manager, which is categorized as a PT_Module. Thus, you end up getting a remark for both the inliner and its pass manager.

[paquette]

Updated diff to reflect current comments on the review.

Highlights:

• Instruction counts are now only updated when there has *definitely* been a change.
• Instruction counts are now computed using deltas on smaller IR unit sizes whenever possible instead of on the entire module size. This will allow us to avoid recomputing module sizes whenever possible.
• Moved getModuleInstrCount into Module and introduced an equivalent function into Function.
• Expanded test so that it checks remarks for Module, Function, CGSCC, and BasicBlock passes.

[paquette]

Now that there's discussion on making the new pass manager the default pass manager, I'm wondering if it'd make sense to just go ahead and implement this functionality there entirely? I was hoping to get it done with the LegacyPassManager first then port it over after.

Also, the test is pretty big now to cover all of the pass manager types. Does anyone think there's a more succinct way to do this?

[davide]

It largely depends on what's your use case, but it's not unreasonable to provide this feature only for the new PM.

[davide]

In D38768#903822, @paquette wrote:

Now that there's discussion on making the new pass manager the default pass manager, I'm wondering if it'd make sense to just go ahead and implement this functionality there entirely? I was hoping to get it done with the LegacyPassManager first then port it over after.

Also, the test is pretty big now to cover all of the pass manager types. Does anyone think there's a more succinct way to do this?

Sorry, I lost part of your question.
I'm not immediately concerned with the size of the test. If you want you can probably split in multiple files but I'm not sure if that buys us something.

[paquette]

Reviving this...

I'd personally find analysis like this useful, especially for quickly diagnosing unintuitive code size changes and building small test-cases. If it's okay for this just to be implemented in the legacy pass manager for now, I'd like to move forward with this. However, I'd also like to know the best path forward for implementing it in the new pass manager.

[paquette]

A bit of cleanup. Updated diff for current pass manager, changed get(IRType)IRCount to a general getIRCount() function.

[anemet]

Mostly small things except for the question on whether we should only compute this when the remark is actually enabled.

include/llvm/IR/Function.h

144–145

getInstructionCount is probably a better name? Later to you have more IR->Instruction.

int -> unsigned?

Remove \p since this it's not a parameter?

lib/Analysis/CallGraphSCCPass.cpp

137

How expensive is this in practice (I know that it's linear but we have many passes)? You may want to do this only if the remark is requested.

You should be able to check this with the DiagnosticHandler in the LLVMContext.

lib/IR/LegacyPassManager.cpp

168–169

Just pass by value?

184

DiagnosticInfoOptimizationBase::Argument -> NV (see many examples elsewhere).

192

Add a comment that this is not using ORE for layering reasons.

[paquette]

Updated diff to address review comments.

• Since we can't use namespace ore here, I kept the DiagnosticInfoOptimizationBase::Argument parameters instead of switching them to NV. I'll submit a follow-up patch to resolve this. I added a FIXME explaining what to do here in the meantime.

• All computation for the remarks is now contained in emitIRSizeChangedRemark, aside from the initial computation of InstrCount. This ensures that we don't count instructions unless we need to.

• General cleanup, etc.

[paquette]

• Updated the test to use globaldce for the module pass
• Ensured that we don't *ever* get the module's instruction count unless the remark has been requested but the user. This is handled in a new helper function, initSizeRemarkInfo
• Improved the test. It only runs opt once per pass type we want to handle. It now no longer has hard-coded values for sizes, which should make sure it isn't terribly flakey

[paquette]

A couple more changes:

• int -> unsigned for getInstructionCount and friends.
• Change names of things that include "IR" to "Instruction".
• Add a few more comments.

[paquette]

Fixed a typo in initSizeRemarkInfo.

[paquette]

A few changes here after running this on some more complicated code.

• I had entirely forgotten to implement it for loop passes in this patch. Added that. ("Why is instcombine making this module 50% bigger? Oh; it's loop unrolling.")

• Changed and LocalChanged aren't reliable for this sort of task. Removed the reliance on that from emitting remarks.

• Getting the initial size of the module at the entry to runOnBlah is unreliable due to missing initialization steps/passes. Moved this down to near where the remark is emitted.

• Added documentation to the test to explain what it's doing, what behaviour it tests, why/why not.

• Made the test enforce that instruction counts and deltas must be within a certain range, and not just any old number.

[anemet]

Mostly nits. LGTM with the requested changes.

(Nice test!)

lib/IR/Function.cpp

198

unsigned

lib/IR/LegacyPassManager.cpp

166–182

Please make this logic more tight. E.g. the initial check on F is a constant true and this last one is a constant false.

test/Other/size-remarks.ll

11

Can you please file a bugzilla that we should support remarks with modules as the code region (Product:tools, Component:opt-viewer).

The tricky part is that Function is pretty deeply baked into the remarks so this may need some work.

[davide]

happy to see this going in when Adam is.

[xbolva00]

lib/Analysis/LoopPass.cpp

154 ↗

(On Diff #147357)

You also use
Module &M = *F.getParent();

2x Module &M = *(F.getParent())
1x Module &M = *F.getParent()

Please check and make it same

[efriedma]

lib/IR/Function.cpp

200

Should we use std::distance(BB.instructionsWithoutDebug.begin(), BB.instructionsWithoutDebug().end()) instead, so the numbers are consistent whether or not debug info is enabled?

[paquette]

Updated patch to address review.

• Fixed stylistic issues
• Changed the basic block instruction count as per @efriedma's suggestion
• Tightened up the logic in emitInstrCountChangedRemark
• Fixed up the leftover int in Function::getInstructionCount
• Small personal nit on the test. [[DELTA:-*[1-9][0-9]*]]->[[DELTA:-?[1-9][0-9]*]]. The negative sign should have 0 or 1 repetitions, not 0 or more.

[paquette]

lib/Analysis/LoopPass.cpp

154 ↗

(On Diff #147357)

Changed them all to *F.getParent()

lib/IR/LegacyPassManager.cpp

184

This should be done in a follow-up patch.

test/Other/size-remarks.ll

11

I'll do that shortly. I'm waiting on a password reset email from bugzilla. :)

[paquette]

Committed as r332739.

https://reviews.llvm.org/rL332739

[xbolva00]

lib/IR/LegacyPassManager.cpp

170

static_cast?

[paquette]

Ah, you’re right.

Changed in r332758.

include/llvm/IR/Function.h

public:
   static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
                           const Twine &N = "", Module *M = nullptr) {
     return new Function(Ty, Linkage, N, M);
   }
 
   // Provide fast operand accessors.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
+  /// Returns the number of IR instructions in this function.
+  /// This is equivalent to the sum of the sizes of each basic block contained
+  /// within this function.
+  int getInstructionCount();
+
   /// Returns the FunctionType for me.
   FunctionType *getFunctionType() const {
     return cast<FunctionType>(getValueType());
   }
 
   /// Returns the type of the ret val.
   Type *getReturnType() const { return getFunctionType()->getReturnType(); }
 

include/llvm/IR/LegacyPassManagers.h

public:
   // Collect AvailableAnalysis from all the active Pass Managers.
   void populateInheritedAnalysis(PMStack &PMS) {
     unsigned Index = 0;
     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.
+  int initSizeRemarkInfo(Module &M);
+
+  /// Emit a remark signifying that the number of IR instructions in the module
+  /// changed.
+  /// This updates the InstrCount parameter if the instruction count in the
+  /// module changed.
+  void emitIRSizeChangedRemark(Pass *P, Module &M, int &InstrCount);
+
 protected:
   // Top level manager.
   PMTopLevelManager *TPM;
 
   // Collection of pass that are managed by this manager
   SmallVector<Pass *, 16> PassVector;
 
   // Collection of Analysis provided by Parent pass manager and

include/llvm/IR/Module.h

 /// @}
 /// @name Module Level Accessors
 /// @{
 
   /// Get the module identifier which is, essentially, the name of the module.
   /// @returns the module identifier as a string
   const std::string &getModuleIdentifier() const { return ModuleID; }
 
+  /// Returns the number of IR instructions in the module.
+  /// This is equivalent to the sum of the IR instruction counts of each
+  /// function contained in the module.
+  int getInstructionCount();
+
   /// Get the module's original source file name. When compiling from
   /// bitcode, this is taken from a bitcode record where it was recorded.
   /// For other compiles it is the same as the ModuleID, which would
   /// contain the source file name.
   const std::string &getSourceFileName() const { return SourceFileName; }
 
   /// Get a short "name" for the module.
   ///

lib/Analysis/CallGraphSCCPass.cpp

 
 char CGPassManager::ID = 0;
 
 bool CGPassManager::RunPassOnSCC(Pass *P, CallGraphSCC &CurSCC,
                                  CallGraph &CG, bool &CallGraphUpToDate,
                                  bool &DevirtualizedCall) {
   bool Changed = false;
   PMDataManager *PM = P->getAsPMDataManager();
+  Module &M = CG.getModule();
+  int InstrCount = initSizeRemarkInfo(M);
 
   if (!PM) {
     CallGraphSCCPass *CGSP = (CallGraphSCCPass*)P;
     if (!CallGraphUpToDate) {
       DevirtualizedCall |= RefreshCallGraph(CurSCC, CG, false);
       CallGraphUpToDate = true;
     }
 
     {
       TimeRegion PassTimer(getPassTimer(CGSP));
       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 (Changed)
+        emitIRSizeChangedRemark(P, M, InstrCount);
     }
     
     // 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
     
     return Changed;
   }
   
   assert(PM->getPassManagerType() == PMT_FunctionPassManager &&
          "Invalid CGPassManager member");
   FPPassManager *FPP = (FPPassManager*)P;
   
   // Run pass P on all functions in the current SCC.
   for (CallGraphNode *CGN : CurSCC) {
     if (Function *F = CGN->getFunction()) {
       dumpPassInfo(P, EXECUTION_MSG, ON_FUNCTION_MSG, F->getName());
       {
         TimeRegion PassTimer(getPassTimer(FPP));
         Changed |= FPP->runOnFunction(*F);
+        if (Changed)
+          emitIRSizeChangedRemark(P, M, InstrCount);
       }
       F->getContext().yield();
     }
   }
   
   // The function pass(es) modified the IR, they may have clobbered the
   // callgraph.
   if (Changed && CallGraphUpToDate) {

lib/IR/Function.cpp

 //===----------------------------------------------------------------------===//
 // Helper Methods in Function
 //===----------------------------------------------------------------------===//
 
 LLVMContext &Function::getContext() const {
   return getType()->getContext();
 }
 
+int Function::getInstructionCount() {
+  int IRCount = 0;
+  for (BasicBlock &BB : BasicBlocks)
+    IRCount += BB.size();
+  return IRCount;
+}
+
 void Function::removeFromParent() {
   getParent()->getFunctionList().remove(getIterator());
 }
 
 void Function::eraseFromParent() {
   getParent()->getFunctionList().erase(getIterator());
 }
 

lib/IR/LegacyPassManager.cpp

 //===- LegacyPassManager.cpp - LLVM Pass Infrastructure Implementation ----===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the legacy LLVM Pass Manager infrastructure.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/ADT/Statistic.h"
+#include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManagers.h"
 #include "llvm/IR/LegacyPassNameParser.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
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;
 }
 
+int PMDataManager::initSizeRemarkInfo(Module &M) {
+  if (!M.getContext().getDiagHandlerPtr()->isAnalysisRemarkEnabled("size-info"))
+    return -1;
+  return M.getInstructionCount();
+}
+
+void PMDataManager::emitIRSizeChangedRemark(Pass *P, Module &M,
+                                            int &CountBefore) {
+  // Did the user request the remark? If not, quit.
+  if (!M.getContext().getDiagHandlerPtr()->isAnalysisRemarkEnabled("size-info"))
+    return;
+
+  // We need a function containing at least one basic block in order to output
+  // remarks.
+  Function *F = nullptr;
+  if (!F) {
+    auto It = std::find_if(M.begin(), M.end(),
+                           [](const Function &Fn) { return Fn.size(); });
+    if (It == M.end())
+      return;
+    F = &*It;
+  }
+
+  // If we have an invalid count, or we don't have anything to output a remark
+  // from, quit.
+  if (!F || CountBefore == -1)
+    return;
+
+  int CountAfter = F->getParent()->getInstructionCount();
 
+  // 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;
+
+  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",
+                                                CountAfter - CountBefore);
+  F->getContext().diagnose(R); // Not using ORE for layering reasons.
+
+  // We've emitted the remark, meaning there was a change in size. Update the
+  // instruction count.
+  CountBefore = CountAfter;
+}
 
 void PassManagerPrettyStackEntry::print(raw_ostream &OS) const {
   if (!V && !M)
     OS << "Releasing pass '";
   else
     OS << "Running pass '";
 
   OS << P->getPassName() << "'";

 /// runOnBasicBlock method.  Keep track of whether any of the passes modifies
 /// the function, and if so, return true.
 bool BBPassManager::runOnFunction(Function &F) {
   if (F.isDeclaration())
     return false;
 
   bool Changed = doInitialization(F);
 
+  Module &M = *F.getParent();
+  int InstrCount = initSizeRemarkInfo(M);
+
   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));
 
         LocalChanged |= BP->runOnBasicBlock(BB);
+        if (LocalChanged)
+          emitIRSizeChangedRemark(BP, M, InstrCount);
       }
 
       Changed |= LocalChanged;
       if (LocalChanged)
         dumpPassInfo(BP, MODIFICATION_MSG, ON_BASICBLOCK_MSG,
                      BB.getName());
       dumpPreservedSet(BP);
       dumpUsedSet(BP);

 /// Execute all of the passes scheduled for execution by invoking
 /// runOnFunction method.  Keep track of whether any of the passes modifies
 /// the function, and if so, return true.
 bool FPPassManager::runOnFunction(Function &F) {
   if (F.isDeclaration())
     return false;
 
   bool Changed = false;
+  Module &M = *(F.getParent());
+  int InstrCount = initSizeRemarkInfo(M);
 
   // Collect inherited analysis from Module level pass manager.
   populateInheritedAnalysis(TPM->activeStack);
 
   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 (LocalChanged)
+        emitIRSizeChangedRemark(FP, M, InstrCount);
     }
 
     Changed |= LocalChanged;
     if (LocalChanged)
       dumpPassInfo(FP, MODIFICATION_MSG, ON_FUNCTION_MSG, F.getName());
     dumpPreservedSet(FP);
     dumpUsedSet(FP);
 
for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
     dumpRequiredSet(MP);
 
     initializeAnalysisImpl(MP);
 
     {
       PassManagerPrettyStackEntry X(MP, M);
       TimeRegion PassTimer(getPassTimer(MP));
 
+      int InstrCount = initSizeRemarkInfo(M);
       LocalChanged |= MP->runOnModule(M);
+      if (LocalChanged)
+        emitIRSizeChangedRemark(MP, M, InstrCount);
     }
 
     Changed |= LocalChanged;
     if (LocalChanged)
       dumpPassInfo(MP, MODIFICATION_MSG, ON_MODULE_MSG,
                    M.getModuleIdentifier());
     dumpPreservedSet(MP);
     dumpUsedSet(MP);

lib/IR/Module.cpp

 
 unsigned Module::getCodeViewFlag() const {
   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("CodeView"));
   if (!Val)
     return 0;
   return cast<ConstantInt>(Val->getValue())->getZExtValue();
 }
 
+int Module::getInstructionCount() {
+  int IRCount = 0;
+  for (Function &F : FunctionList)
+    IRCount += F.getInstructionCount();
+  return IRCount;
+}
+
 Comdat *Module::getOrInsertComdat(StringRef Name) {
   auto &Entry = *ComdatSymTab.insert(std::make_pair(Name, Comdat())).first;
   Entry.second.Name = &Entry;
   return &Entry.second;
 }
 
 PICLevel::Level Module::getPICLevel() const {
   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIC Level"));

test/Other/size-remarks.ll

+; Ensure that IR count remarks in the pass manager work for every type of pass
+; that we handle.
+; The actual IR code doesn't matter for this test. We just want to ensure that
+; we're getting valid size remarks.
+
+; CGSCC passes.
+; 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:[0-9]+]] to [[FINAL:[0-9]+]]; Delta: [[DELTA:[0-9]+]]
+; CGSCC: --- !Analysis
+; CGSCC-NEXT: Pass:            size-info
+; CGSCC-NEXT: Name:            IRSizeChange
+; CGSCC-NEXT: Function:        pluto
+; 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]]'
+
+; Function passes.
+; 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 [[SIZE1:[0-9]+]] to
+; FUNC-SAME: [[SIZE2:[0-9]+]]; Delta: -[[DELTA1:[0-9]+]] 
+; FUNC: remark: <unknown>:0:0: Combine redundant instructions:
+; FUNC-SAME: IR instruction count changed from [[SIZE2]] to
+; FUNC-SAME: [[SIZE3:[0-9]+]]; Delta: -[[DELTA2:[0-9]+]] 
+; FUNC: remark: <unknown>:0:0: Combine redundant instructions:
+; FUNC-SAME: IR instruction count changed from [[SIZE3]] to [[SIZE4:[0-9]+]];
+; FUNC-SAME: Delta: -[[DELTA3:[0-9]+]] 
+; FUNC: --- !Analysis
+; FUNC-NEXT: Pass:            size-info
+; FUNC-NEXT: Name:            IRSizeChange
+; FUNC-NEXT: Function:        pluto
+; 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: --- !Analysis
+; FUNC-NEXT: Pass:            size-info
+; FUNC-NEXT: Name:            IRSizeChange
+; FUNC-NEXT: Function:        pluto
+; 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: --- !Analysis
+; FUNC-NEXT: Pass:            size-info
+; FUNC-NEXT: Name:            IRSizeChange
+; FUNC-NEXT: Function:        pluto
+; FUNC-NEXT: Args:            
+; FUNC-NEXT:  - Pass:            Combine redundant instructions
+; FUNC-NEXT:  - String:          ': IR instruction count changed from '
+; FUNC-NEXT:  - IRInstrsBefore:  '[[SIZE3]]'
+; FUNC-NEXT:  - String:          ' to '
+; FUNC-NEXT:  - IRInstrsAfter:   '[[SIZE4]]'
+; FUNC-NEXT:  - String:          '; Delta: '
+; FUNC-NEXT:  - DeltaInstrCount: '-[[DELTA3]]'
+
+; Make sure it works for module passes.
+
+; Next, make sure it works for function passes.
+; 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: <unknown>:0:0: Dead Global Elimination:
+; MODULE-SAME: IR instruction count changed from [[ORIG:[0-9]+]]
+; MODULE-SAME: to [[FINAL:[0-9]+]]; Delta: -[[DELTA:[0-9]+]]
+; MODULE: --- !Analysis
+; MODULE-NEXT: Pass:            size-info
+; MODULE-NEXT: Name:            IRSizeChange
+; MODULE-NEXT: Function:        baz
+; 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]]'
+
+; Basic block passes.
+; 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 [[ORIG:[0-9]+]]
+; BB-SAME: to [[FINAL:[0-9]+]]; Delta: -[[DELTA:[0-9]+]]
+; BB: --- !Analysis
+; BB-NEXT: Pass:            size-info
+; BB-NEXT: Name:            IRSizeChange
+; BB-NEXT: Function:        pluto
+; 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]]'
+
+declare i1 ()* @boop()
+
+define internal i1 @pluto() {
+        %F = call i1 ()* () @boop( )
+        %c = icmp eq i1 ()* %F, @pluto
+        ret i1 %c
+}
+
+define void @baz() #0 {
+  %x.addr = alloca i32, align 4
+  ret void
+}
+
+define i32 @foo(i32 %x, i32 %y) #0 {
+entry:
+  %x.addr = alloca i32, align 4
+  %y.addr = alloca i32, align 4
+  store i32 %x, i32* %x.addr, align 4
+  store i32 %y, i32* %y.addr, align 4
+  %0 = load i32, i32* %x.addr, align 4
+  %1 = load i32, i32* %y.addr, align 4
+  %add = add nsw i32 %0, %1
+  ret i32 %add
+}
+
+define i32 @bar(i32 %j) #0 {
+entry:
+  %j.addr = alloca i32, align 4
+  store i32 %j, i32* %j.addr, align 4
+  %0 = load i32, i32* %j.addr, align 4
+  %1 = load i32, i32* %j.addr, align 4
+  %sub = sub nsw i32 %1, 2
+  %call = call i32 @foo(i32 %0, i32 %sub)
+  ret i32 %call
+}