[llvm-mca] Add the ability to mark regions of code for analysis (PR36875)

[andreadb]

Summary

This patch teaches llvm-mca how to parse code comments in search for special "markers" used to select regions of code.

Example:

# LLVM-MCA-START My Code Region
  ....
# LLVM-MCA-END

The MCAsmLexer now delegates to an object of class MCACommentParser (i.e. an AsmCommentConsumer) the parsing of code comments to search for begin/end code region markers.

A comment starting with substring "LLVM-MCA-START" marks the beginning of a new region of code.
A comment starting with substring "LLVM-MCA-END" marks the end of the last region.

This implementation doesn't allow regions to overlap. Each region can have a optional description; internally, each region is described by a range of source code locations (SMLoc).

MCInst objects are added to a region R only if the source location for the MCInst is in the range of locations specified by R.

By default, the tool allocates an implicit "Default" code region which contains every source location.
See new tests llvm-mca-marker-*.s for a few examples.

How this affect the report generated by the tool?

A new Backend object is created for every region. So, the analysis is conducted on every parsed code region.
The final report is the union of the reports generated for every code region. Note that empty regions are skipped.

Special "[#] Code Region - ..." strings are used in the report to mark the portion which is specific to a code region only. For example, see llvm-mca-markers-5.s.

Please let me know if okay to commit.

Thanks
-Andrea

[courbet]

Only minor comments, LGTM otherwise.

tools/llvm-mca/CodeRegion.cpp

27

assert(Regions.empty() && "missing Default region");
(for the reader)

41

ditto

tools/llvm-mca/CodeRegion.h

9

Please add a file comment.

tools/llvm-mca/SourceMgr.h

27

I think having the const outside of the type would make semantics of InstVec& Sequence and InstVec &MCInstSequence clearer.

[andreadb]

tools/llvm-mca/CodeRegion.h

9

Ouch... I thought that something was missing.

Thanks for spotting it. I will add it.

[RKSimon]

LGTM once the docs/comments have been updated

[alekseyshl]

There's a problem with this patch:
http://lab.llvm.org:8011/builders/sanitizer-ppc64be-linux/builds/6280

[RKSimon]

In D45433#1062145, @alekseyshl wrote:

There's a problem with this patch:
http://lab.llvm.org:8011/builders/sanitizer-ppc64be-linux/builds/6280

This should be fixed by rL329592 - thanks @MaskRay

test/tools/llvm-mca/X86/llvm-mca-markers-1.s

+# RUN: not llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=btver2 %s 2>&1 | FileCheck %s
+
+# LLVM-MCA-BEGIN
+# LLVM-MCA-END
+
+# LLVM-MCA-BEGIN
+# LLVM-MCA-END
+
+
+# CHECK: error: no assembly instructions found.

test/tools/llvm-mca/X86/llvm-mca-markers-2.s

+# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=btver2 -iterations=1 -resource-pressure=false < %s | FileCheck %s
+
+  add %edi, %esi
+# LLVM-MCA-END
+  add %esi, %eax
+
+
+# CHECK:      [0] Code Region - Default
+
+# CHECK:      Iterations:     1
+# CHECK-NEXT: Instructions:   1
+
+# CHECK:      Instruction Info:
+# CHECK-NEXT: [1]: #uOps
+# CHECK-NEXT: [2]: Latency
+# CHECK-NEXT: [3]: RThroughput
+# CHECK-NEXT: [4]: MayLoad
+# CHECK-NEXT: [5]: MayStore
+# CHECK-NEXT: [6]: HasSideEffects
+
+# CHECK:      [1]    [2]    [3]    [4]    [5]    [6]  Instructions:
+# CHECK-NEXT:  1      1     0.50                      addl  %edi, %esi

test/tools/llvm-mca/X86/llvm-mca-markers-3.s

+# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=btver2 -iterations=1 -resource-pressure=false < %s | FileCheck %s
+
+  add %esi, %edi
+# LLVM-MCA-BEGIN foo
+  add %edi, %eax
+
+
+# CHECK: [0] Code Region - foo
+
+# CHECK:      Iterations:     1
+# CHECK-NEXT: Instructions:   1
+
+# CHECK:      Instruction Info:
+# CHECK-NEXT: [1]: #uOps
+# CHECK-NEXT: [2]: Latency
+# CHECK-NEXT: [3]: RThroughput
+# CHECK-NEXT: [4]: MayLoad
+# CHECK-NEXT: [5]: MayStore
+# CHECK-NEXT: [6]: HasSideEffects
+
+# CHECK:      [1]    [2]    [3]    [4]    [5]    [6]  Instructions:
+# CHECK-NEXT:  1      1     0.50                      addl  %edi, %eax

test/tools/llvm-mca/X86/llvm-mca-markers-4.s

+# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=btver2 -iterations=1 -resource-pressure=false < %s | FileCheck %s
+
+# LLVM-MCA-BEGIN Empty
+  # Empty sequence
+# LLVM-MCA-END
+
+# LLVM-MCA-BEGIN NotEmpty
+  add %edi, %eax
+# LLVM-MCA-END
+
+
+# CHECK: [0] Code Region -  NotEmpty
+
+# CHECK:      Iterations:     1
+# CHECK-NEXT: Instructions:   1
+
+
+# CHECK:      Instruction Info:
+# CHECK-NEXT: [1]: #uOps
+# CHECK-NEXT: [2]: Latency
+# CHECK-NEXT: [3]: RThroughput
+# CHECK-NEXT: [4]: MayLoad
+# CHECK-NEXT: [5]: MayStore
+# CHECK-NEXT: [6]: HasSideEffects
+
+# CHECK:      [1]    [2]    [3]    [4]    [5]    [6]  Instructions:
+# CHECK-NEXT:  1      1     0.50                      addl  %edi, %eax

test/tools/llvm-mca/X86/llvm-mca-markers-5.s

+# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=btver2 -iterations=1 -resource-pressure=false < %s | FileCheck %s
+
+  add %ecx, %esi
+# LLVM-MCA-BEGIN First Region
+  add %edi, %esi
+# LLVM-MCA-END
+# LLVM-MCA-BEGIN Second Region
+  add %esi, %edx
+# LLVM-MCA-END
+# LLVM-MCA-BEGIN Third Region
+  add %edx, %eax
+# LLVM-MCA-END
+  add %esi, %eax
+
+
+# CHECK:      [0] Code Region -  First Region
+
+# CHECK:      Instruction Info:
+# CHECK-NEXT: [1]: #uOps
+# CHECK-NEXT: [2]: Latency
+# CHECK-NEXT: [3]: RThroughput
+# CHECK-NEXT: [4]: MayLoad
+# CHECK-NEXT: [5]: MayStore
+# CHECK-NEXT: [6]: HasSideEffects
+
+# CHECK:      [1]    [2]    [3]    [4]    [5]    [6]  Instructions:
+# CHECK-NEXT:  1      1     0.50                      addl  %edi, %esi
+
+# CHECK:      [1] Code Region -  Second Region
+
+# CHECK:      Instruction Info:
+# CHECK-NEXT: [1]: #uOps
+# CHECK-NEXT: [2]: Latency
+# CHECK-NEXT: [3]: RThroughput
+# CHECK-NEXT: [4]: MayLoad
+# CHECK-NEXT: [5]: MayStore
+# CHECK-NEXT: [6]: HasSideEffects
+
+# CHECK:      [1]    [2]    [3]    [4]    [5]    [6]  Instructions:
+# CHECK-NEXT:  1      1     0.50                      addl  %esi, %edx
+
+# CHECK:      [2] Code Region -  Third Region
+
+# CHECK:      Instruction Info:
+# CHECK-NEXT: [1]: #uOps
+# CHECK-NEXT: [2]: Latency
+# CHECK-NEXT: [3]: RThroughput
+# CHECK-NEXT: [4]: MayLoad
+# CHECK-NEXT: [5]: MayStore
+# CHECK-NEXT: [6]: HasSideEffects
+
+# CHECK:      [1]    [2]    [3]    [4]    [5]    [6]  Instructions:
+# CHECK-NEXT:  1      1     0.50                      addl  %edx, %eax

test/tools/llvm-mca/X86/llvm-mca-markers-6.s

+# RUN: not llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=btver2 %s 2>&1 | FileCheck %s
+
+# LLVM-MCA-BEGIN  foo
+
+# LLVM-MCA-BEGIN  bar
+
+# LLVM-MCA-END
+
+
+# CHECK:      llvm-mca-markers-6.s:5:2: warning: Ignoring invalid region start
+# CHECK-NEXT: # LLVM-MCA-BEGIN  bar
+# CHECK-NEXT:  ^
+# CHECK-NEXT: error: no assembly instructions found.

test/tools/llvm-mca/X86/llvm-mca-markers-7.s

+# RUN: not llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=btver2 %s 2>&1 | FileCheck %s
+
+# LLVM-MCA-BEGIN  foo
+
+# LLVM-MCA-END
+
+# LLVM-MCA-END
+
+
+# CHECK:      llvm-mca-markers-7.s:7:2: warning: Ignoring invalid region end
+# CHECK-NEXT: # LLVM-MCA-END
+# CHECK-NEXT:  ^

tools/llvm-mca/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmPrinters
   AllTargetsAsmParsers
   AllTargetsDescs
   AllTargetsDisassemblers
   AllTargetsInfos
   MC
   MCParser
   Support
   )
 
 add_llvm_tool(llvm-mca
   Backend.cpp
   BackendPrinter.cpp
   BackendStatistics.cpp
+  CodeRegion.cpp
   Dispatch.cpp
   HWEventListener.cpp
   InstrBuilder.cpp
   Instruction.cpp
   InstructionInfoView.cpp
   InstructionTables.cpp
   LSUnit.cpp
   llvm-mca.cpp
   RegisterFileStatistics.cpp
   ResourcePressureView.cpp
   Scheduler.cpp
   Support.cpp
   SummaryView.cpp
   TimelineView.cpp
   View.cpp
   )

tools/llvm-mca/CodeRegion.h

+//===-------------------------- CodeRegion.h -------------------*- C++ -* -===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_MCA_CODEREGION_H
+#define LLVM_TOOLS_LLVM_MCA_CODEREGION_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/MC/MCInst.h"
+#include "llvm/Support/SMLoc.h"
+#include "llvm/Support/SourceMgr.h"
+#include <vector>
+
+namespace mca {
+
+class CodeRegion {
+  // An optional descriptor for this region.
+  llvm::StringRef Description;
+  // Instructions that form this region.
+  std::vector<std::unique_ptr<const llvm::MCInst>> Instructions;
+  // Source location range.
+  llvm::SMLoc RangeStart;
+  llvm::SMLoc RangeEnd;
+
+  CodeRegion(const CodeRegion &) = delete;
+  CodeRegion &operator=(const CodeRegion &) = delete;
+
+public:
+  CodeRegion(llvm::StringRef Desc, llvm::SMLoc Start)
+      : Description(Desc), RangeStart(Start), RangeEnd() {}
+
+  void addInstruction(std::unique_ptr<const llvm::MCInst> Instruction) {
+    Instructions.emplace_back(std::move(Instruction));
+  }
+
+  llvm::SMLoc startLoc() const { return RangeStart; }
+  llvm::SMLoc endLoc() const { return RangeEnd; }
+
+  void setEndLocation(llvm::SMLoc End) { RangeEnd = End; }
+  bool empty() const { return Instructions.empty(); }
+  bool isLocInRange(llvm::SMLoc Loc) const;
+
+  const std::vector<std::unique_ptr<const llvm::MCInst>> &
+  getInstructions() const {
+    return Instructions;
+  }
+
+  llvm::StringRef getDescription() const { return Description; }
+};
+
+class CodeRegions {
+  // A source manager. Used by the tool to generate meaningful warnings.
+  llvm::SourceMgr &SM;
+
+  std::vector<std::unique_ptr<CodeRegion>> Regions;
+
+  // Construct a new region of code guarded by LLVM-MCA comments.
+  void addRegion(llvm::StringRef Description, llvm::SMLoc Loc) {
+    Regions.emplace_back(llvm::make_unique<CodeRegion>(Description, Loc));
+  }
+
+  CodeRegions(const CodeRegions &) = delete;
+  CodeRegions &operator=(const CodeRegions &) = delete;
+
+public:
+  typedef std::vector<std::unique_ptr<CodeRegion>>::iterator iterator;
+  typedef std::vector<std::unique_ptr<CodeRegion>>::const_iterator
+      const_iterator;
+
+  iterator begin() { return Regions.begin(); }
+  iterator end() { return Regions.end(); }
+  const_iterator begin() const { return Regions.cbegin(); }
+  const_iterator end() const { return Regions.cend(); }
+
+  void beginRegion(llvm::StringRef Description, llvm::SMLoc Loc);
+  void endRegion(llvm::SMLoc Loc);
+  void addInstruction(std::unique_ptr<const llvm::MCInst> Instruction);
+
+  CodeRegions(llvm::SourceMgr &S) : SM(S) {
+    // Create a default region for the input code sequence.
+    addRegion("Default", llvm::SMLoc());
+  }
+
+  const std::vector<std::unique_ptr<const llvm::MCInst>> &
+  getInstructionSequence(unsigned Idx) const {
+    return Regions[Idx]->getInstructions();
+  }
+
+  bool empty() const {
+    return std::all_of(Regions.begin(), Regions.end(),
+                       [](const std::unique_ptr<CodeRegion> &Region) {
+                         return Region->empty();
+                       });
+  }
+};
+
+} // namespace mca
+
+#endif

tools/llvm-mca/CodeRegion.cpp

+//===-------------------------- CodeRegion.cpp -----------------*- C++ -* -===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#include "CodeRegion.h"
+
+using namespace llvm;
+
+namespace mca {
+
+bool CodeRegion::isLocInRange(SMLoc Loc) const {
+  if (RangeEnd.isValid() && Loc.getPointer() > RangeEnd.getPointer())
+    return false;
+  if (RangeStart.isValid() && Loc.getPointer() < RangeStart.getPointer())
+    return false;
+  return true;
+}
+
+void CodeRegions::beginRegion(StringRef Description, SMLoc Loc) {
+  const CodeRegion &CurrentRegion = *Regions.back();
+  if (CurrentRegion.startLoc().isValid() && !CurrentRegion.endLoc().isValid()) {
+    SM.PrintMessage(Loc, SourceMgr::DK_Warning,
+                    "Ignoring invalid region start");
+    return;
+  }
+
+  // Remove the default region if there are user defined regions.
+  if (!CurrentRegion.startLoc().isValid())
+    Regions.erase(Regions.begin());
+  addRegion(Description, Loc);
+}
+
+void CodeRegions::endRegion(SMLoc Loc) {
+  CodeRegion &CurrentRegion = *Regions.back();
+  if (CurrentRegion.endLoc().isValid()) {
+    SM.PrintMessage(Loc, SourceMgr::DK_Warning, "Ignoring invalid region end");
+    return;
+  }
+
+  CurrentRegion.setEndLocation(Loc);
+}
+
+void CodeRegions::addInstruction(std::unique_ptr<const MCInst> Instruction) {
+  const SMLoc &Loc = Instruction->getLoc();
+  const auto It =
+      std::find_if(Regions.rbegin(), Regions.rend(),
+                   [Loc](const std::unique_ptr<CodeRegion> &Region) {
+                     return Region->isLocInRange(Loc);
+                   });
+  if (It != Regions.rend())
+    (*It)->addInstruction(std::move(Instruction));
+}
+
+} // namespace mca

tools/llvm-mca/SourceMgr.h

 #include "llvm/MC/MCInst.h"
 #include <vector>
 
 namespace mca {
 
 typedef std::pair<unsigned, const llvm::MCInst *> InstRef;
 
 class SourceMgr {
-  using InstVec = std::vector<std::unique_ptr<const llvm::MCInst>>;
-  InstVec Sequence;
+  using InstVec = const std::vector<std::unique_ptr<const llvm::MCInst>>;
+  InstVec &Sequence;
   unsigned Current;
   unsigned Iterations;
   static const unsigned DefaultIterations = 70;
 
 public:
-  SourceMgr(unsigned NumIterations)
-      : Current(0),
+  SourceMgr(InstVec &MCInstSequence, unsigned NumIterations)
+      : Sequence(MCInstSequence), Current(0),
         Iterations(NumIterations ? NumIterations : DefaultIterations) {}
 
   unsigned getCurrentIteration() const { return Current / Sequence.size(); }
   unsigned getNumIterations() const { return Iterations; }
   unsigned size() const { return Sequence.size(); }
   const InstVec &getSequence() const { return Sequence; }
   InstVec &getSequence() { return Sequence; }
 

tools/llvm-mca/llvm-mca.cpp

 // The target defaults to the host target.
 // The cpu defaults to 'generic'.
 // The output defaults to standard output.
 //
 //===----------------------------------------------------------------------===//
 
 #include "BackendPrinter.h"
 #include "BackendStatistics.h"
+#include "CodeRegion.h"
 #include "InstructionInfoView.h"
 #include "InstructionTables.h"
 #include "RegisterFileStatistics.h"
 #include "ResourcePressureView.h"
 #include "SummaryView.h"
 #include "TimelineView.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
if (!TheTarget) {
     errs() << ProgName << ": " << Error;
     return nullptr;
   }
 
   // Return the found target.
   return TheTarget;
 }
 
+// A comment consumer that parses strings.
+// The only valid tokens are strings.
+class MCACommentConsumer : public AsmCommentConsumer {
+public:
+  mca::CodeRegions &Regions;
+
+  MCACommentConsumer(mca::CodeRegions &R) : Regions(R) {}
+  void HandleComment(SMLoc Loc, StringRef CommentText) override {
+    // Skip empty comments.
+    StringRef Comment(CommentText);
+    if (Comment.empty())
+      return;
+
+    // Skip spaces and tabs
+    unsigned Position = Comment.find_first_not_of(" \t");
+    if (Position >= Comment.size())
+      // we reached the end of the comment. Bail out.
+      return;
+
+    Comment = Comment.drop_front(Position);
+    if (Comment.consume_front("LLVM-MCA-END")) {
+      Regions.endRegion(Loc);
+      return;
+    }
+
+    // Now try to parse string LLVM-MCA-BEGIN
+    if (!Comment.consume_front("LLVM-MCA-BEGIN"))
+      return;
+
+    // Skip spaces and tabs
+    Position = Comment.find_first_not_of(" \t");
+    if (Position < Comment.size())
+      Comment.drop_front(Position);
+    // Use the rest of the string as a descriptor for this code snippet.
+    Regions.beginRegion(Comment, Loc);
+  }
+};
+
 int AssembleInput(const char *ProgName, MCAsmParser &Parser,
                   const Target *TheTarget, MCSubtargetInfo &STI,
                   MCInstrInfo &MCII, MCTargetOptions &MCOptions) {
   std::unique_ptr<MCTargetAsmParser> TAP(
       TheTarget->createMCAsmParser(STI, Parser, MCII, MCOptions));
 
   if (!TAP) {
     errs() << ProgName
ErrorOr<std::unique_ptr<ToolOutputFile>> getOutputStream() {
   auto Out =
       llvm::make_unique<ToolOutputFile>(OutputFilename, EC, sys::fs::F_None);
   if (!EC)
     return std::move(Out);
   return EC;
 }
 
 class MCStreamerWrapper final : public MCStreamer {
-  using InstVec = std::vector<std::unique_ptr<const MCInst>>;
-  InstVec &Insts;
+  mca::CodeRegions &Regions;
 
 public:
-  MCStreamerWrapper(MCContext &Context, InstVec &Vec)
-      : MCStreamer(Context), Insts(Vec) {}
+  MCStreamerWrapper(MCContext &Context, mca::CodeRegions &R)
+      : MCStreamer(Context), Regions(R) {}
 
   // We only want to intercept the emission of new instructions.
   virtual void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
                                bool /* unused */) override {
-    Insts.emplace_back(new MCInst(Inst));
+    Regions.addInstruction(llvm::make_unique<const MCInst>(Inst));
   }
 
   bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override {
     return true;
   }
 
   void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override {}
   void EmitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
                     uint64_t Size = 0, unsigned ByteAlignment = 0) override {}
   void EmitGPRel32Value(const MCExpr *Value) override {}
   void BeginCOFFSymbolDef(const MCSymbol *Symbol) override {}
   void EmitCOFFSymbolStorageClass(int StorageClass) override {}
   void EmitCOFFSymbolType(int Type) override {}
   void EndCOFFSymbolDef() override {}
 
-  const InstVec &GetInstructionSequence() const { return Insts; }
+  const std::vector<std::unique_ptr<const MCInst>> &
+  GetInstructionSequence(unsigned Index) const {
+    return Regions.getInstructionSequence(Index);
+  }
 };
 } // end of anonymous namespace
 
 int main(int argc, char **argv) {
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 
int main(int argc, char **argv) {
   assert(MAI && "Unable to create target asm info!");
 
   MCObjectFileInfo MOFI;
   MCContext Ctx(MAI.get(), MRI.get(), &MOFI, &SrcMgr);
   MOFI.InitMCObjectFileInfo(TheTriple, /* PIC= */ false, Ctx);
 
   std::unique_ptr<buffer_ostream> BOS;
 
-  std::unique_ptr<mca::SourceMgr> S = llvm::make_unique<mca::SourceMgr>(
-      PrintInstructionTables ? 1 : Iterations);
-  MCStreamerWrapper Str(Ctx, S->getSequence());
+  mca::CodeRegions Regions(SrcMgr);
+  MCStreamerWrapper Str(Ctx, Regions);
 
   std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
   std::unique_ptr<MCSubtargetInfo> STI(
       TheTarget->createMCSubtargetInfo(TripleName, MCPU, /* FeaturesStr */ ""));
   if (!STI->isCPUStringValid(MCPU))
     return 1;
 
   if (!STI->getSchedModel().isOutOfOrder()) {
int main(int argc, char **argv) {
   if (!IP) {
     errs() << "error: unable to create instruction printer for target triple '"
            << TheTriple.normalize() << "' with assembly variant "
            << OutputAsmVariant << ".\n";
     return 1;
   }
 
   std::unique_ptr<MCAsmParser> P(createMCAsmParser(SrcMgr, Ctx, Str, *MAI));
+  MCAsmLexer &Lexer = P->getLexer();
+  MCACommentConsumer CC(Regions);
+  Lexer.setCommentConsumer(&CC);
+
   if (AssembleInput(ProgName, *P, TheTarget, *STI, *MCII, MCOptions))
     return 1;
 
-  if (S->isEmpty()) {
+  if (Regions.empty()) {
     errs() << "error: no assembly instructions found.\n";
     return 1;
   }
 
   // Now initialize the output file.
   auto OF = getOutputStream();
   if (std::error_code EC = OF.getError()) {
     errs() << EC.message() << '\n';
     return 1;
   }
 
   std::unique_ptr<llvm::ToolOutputFile> TOF = std::move(*OF);
 
   const MCSchedModel &SM = STI->getSchedModel();
 
   unsigned Width = SM.IssueWidth;
   if (DispatchWidth)
     Width = DispatchWidth;
 
   // Create an instruction builder.
   mca::InstrBuilder IB(*STI, *MCII);
 
+  // Number each region in the sequence.
+  unsigned RegionIdx = 0;
+  for (const std::unique_ptr<mca::CodeRegion> &Region : Regions) {
+    // Skip empty code regions.
+    if (Region->empty())
+      continue;
+
+    // Don't print the header of this region if it is the default region, and
+    // it doesn't have an end location.
+    if (Region->startLoc().isValid() || Region->endLoc().isValid()) {
+      TOF->os() << "\n[" << RegionIdx++ << "] Code Region";
+      StringRef Desc = Region->getDescription();
+      if (!Desc.empty())
+        TOF->os() << " - " << Desc;
+      TOF->os() << "\n\n";
+    }
+
+    mca::SourceMgr S(Region->getInstructions(),
+                     PrintInstructionTables ? 1 : Iterations);
+
     if (PrintInstructionTables) {
-    mca::InstructionTables IT(STI->getSchedModel(), IB, *S);
+      mca::InstructionTables IT(STI->getSchedModel(), IB, S);
 
       if (PrintInstructionInfoView) {
         IT.addView(
-          llvm::make_unique<mca::InstructionInfoView>(*STI, *MCII, *S, *IP));
+            llvm::make_unique<mca::InstructionInfoView>(*STI, *MCII, S, *IP));
       }
 
-    IT.addView(llvm::make_unique<mca::ResourcePressureView>(*STI, *IP, *S));
+      IT.addView(llvm::make_unique<mca::ResourcePressureView>(*STI, *IP, S));
       IT.run();
       IT.printReport(TOF->os());
-    TOF->keep();
-    return 0;
+      continue;
     }
 
-  mca::Backend B(*STI, *MRI, IB, *S, Width, RegisterFileSize, LoadQueueSize,
+    mca::Backend B(*STI, *MRI, IB, S, Width, RegisterFileSize, LoadQueueSize,
                    StoreQueueSize, AssumeNoAlias);
     mca::BackendPrinter Printer(B);
 
-  Printer.addView(llvm::make_unique<mca::SummaryView>(*S, Width));
-
+    Printer.addView(llvm::make_unique<mca::SummaryView>(S, Width));
     if (PrintInstructionInfoView)
       Printer.addView(
-        llvm::make_unique<mca::InstructionInfoView>(*STI, *MCII, *S, *IP));
+          llvm::make_unique<mca::InstructionInfoView>(*STI, *MCII, S, *IP));
 
     if (PrintModeVerbose)
       Printer.addView(llvm::make_unique<mca::BackendStatistics>(*STI));
 
     if (PrintRegisterFileStats)
       Printer.addView(llvm::make_unique<mca::RegisterFileStatistics>(*STI));
 
     if (PrintResourcePressureView)
       Printer.addView(
-        llvm::make_unique<mca::ResourcePressureView>(*STI, *IP, *S));
+          llvm::make_unique<mca::ResourcePressureView>(*STI, *IP, S));
 
     if (PrintTimelineView) {
       Printer.addView(llvm::make_unique<mca::TimelineView>(
-        *STI, *IP, *S, TimelineMaxIterations, TimelineMaxCycles));
+          *STI, *IP, S, TimelineMaxIterations, TimelineMaxCycles));
     }
 
     B.run();
     Printer.printReport(TOF->os());
-  TOF->keep();
+  }
 
+  TOF->keep();
   return 0;
 }