[BOLT] Add general support for multiple binary profiles (WIP)

[Amir]

Summary

Add support for

• specifying multiple profiles on the command line
• writing YAML profile containing multiple sub-profiles

No support for reading YAML profile with sub-profiles or correctly updating
function profile using multiple profiles.

bolt/include/bolt/Profile/ProfileYAMLMapping.h

static void bitset(IO &io, PROFILE_PF &value) {
     io.bitSetCase(value, "lbr", BinaryFunction::PF_LBR);
     io.bitSetCase(value, "sample", BinaryFunction::PF_SAMPLE);
     io.bitSetCase(value, "memevent", BinaryFunction::PF_MEMEVENT);
   }
 };
 
 namespace bolt {
 struct BinaryProfileHeader {
-  uint32_t Version{1};
+  uint32_t Version{2};
   std::string FileName; // Name of the profiled binary.
   std::string Id;       // BuildID.
   PROFILE_PF Flags{BinaryFunction::PF_NONE};
   // Type of the profile.
   std::string Origin;     // How the profile was obtained.
   std::string EventNames; // Events used for sample profile.
 };
 } // end namespace bolt
static void mapping(IO &YamlIO, bolt::BinaryProfile &BP) {
     YamlIO.mapRequired("header", BP.Header);
     YamlIO.mapRequired("functions", BP.Functions);
   }
 };
 
 } // end namespace yaml
 } // end namespace llvm
 
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::bolt::BinaryProfile)
+
 #endif

bolt/include/bolt/Profile/YAMLProfileWriter.h

 #define BOLT_PROFILE_YAML_PROFILE_WRITER_H
 
 #include "llvm/Support/raw_ostream.h"
 #include <system_error>
 
 namespace llvm {
 namespace bolt {
 class RewriteInstance;
+class ProfileReaderBase;
 
 class YAMLProfileWriter {
   YAMLProfileWriter() = delete;
 
   std::string Filename;
 
   std::unique_ptr<raw_fd_ostream> OS;
 
 public:
   explicit YAMLProfileWriter(const std::string &Filename)
       : Filename(Filename) {}
 
   /// Save execution profile for that instance.
-  std::error_code writeProfile(const RewriteInstance &RI);
+  std::error_code
+  writeProfile(const RewriteInstance &RI,
+               std::vector<std::unique_ptr<ProfileReaderBase>> &ProfileReaders);
 };
 
 } // namespace bolt
 } // namespace llvm
 
 #endif

bolt/include/bolt/Rewrite/RewriteInstance.h

public:
   /// ELF note section containing build-id information.
   void parseBuildID();
 
   /// The build-id is typically a stream of 20 bytes. Return these bytes in
   /// printable hexadecimal form if they are available, or std::nullopt
   /// otherwise.
   std::optional<std::string> getPrintableBuildID() const;
 
-  /// If this instance uses a profile, return appropriate profile reader.
-  const ProfileReaderBase *getProfileReader() const {
-    return ProfileReader.get();
-  }
-
 private:
   using ELF64LEPhdrTy = object::ELF64LEFile::Elf_Phdr;
 
   /// Populate array of binary functions and other objects of interest
   /// from meta data in the file.
   void discoverFileObjects();
 
   /// Process fragments, locate parent functions.
private:
 
   /// Mark functions that are not meant for processing as ignored.
   void selectFunctionsToProcess();
 
   /// Read information from debug sections.
   void readDebugInfo();
 
   /// Read profile data without having disassembled functions available.
+  void preprocessProfile(std::unique_ptr<ProfileReaderBase> &ProfileReader);
   void preprocessProfileData();
 
   void processProfileDataPreCFG();
 
   /// Associate profile data with functions and data objects.
   void processProfileData();
 
   /// Disassemble each function in the binary and associate it with a
private:
   /// An instance of the input binary we are processing, externally owned.
   llvm::object::ELFObjectFileBase *InputFile;
 
   /// Command line args used to process binary.
   const int Argc;
   const char *const *Argv;
   StringRef ToolPath;
 
-  std::unique_ptr<ProfileReaderBase> ProfileReader;
+  std::vector<std::unique_ptr<ProfileReaderBase>> ProfileReaders;
 
   std::unique_ptr<BinaryContext> BC;
   std::unique_ptr<CFIReaderWriter> CFIRdWrt;
 
   // Run ExecutionEngine linker with custom memory manager and symbol resolver.
   std::unique_ptr<RuntimeDyld> RTDyld;
 
   /// Output file where we mix original code from the input binary and

bolt/include/bolt/Utils/CommandLineOpts.h

 extern llvm::cl::opt<unsigned long long> HeatmapMaxAddress;
 extern llvm::cl::opt<unsigned long long> HeatmapMinAddress;
 extern llvm::cl::opt<bool> HotData;
 extern llvm::cl::opt<bool> HotFunctionsAtEnd;
 extern llvm::cl::opt<bool> HotText;
 extern llvm::cl::opt<bool> Hugify;
 extern llvm::cl::opt<bool> Instrument;
 extern llvm::cl::opt<std::string> OutputFilename;
-extern llvm::cl::opt<std::string> PerfData;
+extern llvm::cl::list<std::string> PerfData;
 extern llvm::cl::opt<bool> PrintCacheMetrics;
 extern llvm::cl::opt<bool> PrintSections;
 
 // The format to use with -o in aggregation mode (perf2bolt)
 enum ProfileFormatKind { PF_Fdata, PF_YAML };
 
 extern llvm::cl::opt<ProfileFormatKind> ProfileFormat;
 extern llvm::cl::opt<bool> SplitEH;

bolt/lib/Profile/YAMLProfileWriter.cpp

for (const BinaryBasicBlock *Successor : BB->successors()) {
       ++BranchInfo;
     }
 
     YamlBF.Blocks.emplace_back(YamlBB);
   }
 }
 } // end anonymous namespace
 
-std::error_code YAMLProfileWriter::writeProfile(const RewriteInstance &RI) {
+std::error_code YAMLProfileWriter::writeProfile(
+    const RewriteInstance &RI,
+    std::vector<std::unique_ptr<ProfileReaderBase>> &ProfileReaders) {
   const BinaryContext &BC = RI.getBinaryContext();
   const auto &Functions = BC.getBinaryFunctions();
 
   std::error_code EC;
   OS = std::make_unique<raw_fd_ostream>(Filename, EC, sys::fs::OF_None);
   if (EC) {
     errs() << "BOLT-WARNING: " << EC.message() << " : unable to open "
            << Filename << " for output.\n";
     return EC;
   }
 
+  std::vector<yaml::bolt::BinaryProfile> BPs;
+  for (std::unique_ptr<ProfileReaderBase> &ProfileReader : ProfileReaders) {
     yaml::bolt::BinaryProfile BP;
 
     // Fill out the header info.
-  BP.Header.Version = 1;
+    BP.Header.Version = 2;
     BP.Header.FileName = std::string(BC.getFilename());
     std::optional<StringRef> BuildID = BC.getFileBuildID();
     BP.Header.Id = BuildID ? std::string(*BuildID) : "<unknown>";
-  BP.Header.Origin = std::string(RI.getProfileReader()->getReaderName());
+    BP.Header.Origin = std::string(ProfileReader->getReaderName());
 
-  StringSet<> EventNames = RI.getProfileReader()->getEventNames();
+    StringSet<> EventNames = ProfileReader->getEventNames();
     if (!EventNames.empty()) {
       std::string Sep;
       for (const StringMapEntry<std::nullopt_t> &EventEntry : EventNames) {
         BP.Header.EventNames += Sep + EventEntry.first().str();
         Sep = ",";
       }
     }
 
     // Make sure the profile is consistent across all functions.
     uint16_t ProfileFlags = BinaryFunction::PF_NONE;
     for (const auto &BFI : Functions) {
       const BinaryFunction &BF = BFI.second;
       if (BF.hasProfile() && !BF.empty()) {
         assert(BF.getProfileFlags() != BinaryFunction::PF_NONE);
         if (ProfileFlags == BinaryFunction::PF_NONE)
           ProfileFlags = BF.getProfileFlags();
 
         assert(BF.getProfileFlags() == ProfileFlags &&
                "expected consistent profile flags across all functions");
       }
     }
     BP.Header.Flags = ProfileFlags;
 
     // Add all function objects.
     for (const auto &BFI : Functions) {
       const BinaryFunction &BF = BFI.second;
       if (BF.hasProfile()) {
-      if (!BF.hasValidProfile() && !RI.getProfileReader()->isTrustedSource())
+        if (!BF.hasValidProfile() && !ProfileReader->isTrustedSource())
           continue;
 
         yaml::bolt::BinaryFunctionProfile YamlBF;
         convert(BF, YamlBF);
         BP.Functions.emplace_back(YamlBF);
       }
     }
+    BPs.push_back(BP);
+  }
 
   // Write the profile.
   yaml::Output Out(*OS, nullptr, 0);
-  Out << BP;
+  Out << BPs;
 
   return std::error_code();
 }
 
 } // namespace bolt
 } // namespace llvm

bolt/lib/Rewrite/RewriteInstance.cpp

 }
 
 RewriteInstance::~RewriteInstance() {}
 
 Error RewriteInstance::setProfile(StringRef Filename) {
   if (!sys::fs::exists(Filename))
     return errorCodeToError(make_error_code(errc::no_such_file_or_directory));
 
-  if (ProfileReader) {
-    // Already exists
-    return make_error<StringError>(Twine("multiple profiles specified: ") +
-                                       ProfileReader->getFilename() + " and " +
-                                       Filename,
-                                   inconvertibleErrorCode());
-  }
-
+  std::unique_ptr<ProfileReaderBase> ProfileReader;
   // Spawn a profile reader based on file contents.
   if (DataAggregator::checkPerfDataMagic(Filename))
     ProfileReader = std::make_unique<DataAggregator>(Filename);
   else if (YAMLProfileReader::isYAML(Filename))
     ProfileReader = std::make_unique<YAMLProfileReader>(Filename);
   else
     ProfileReader = std::make_unique<DataReader>(Filename);
 
+  ProfileReaders.emplace_back(std::move(ProfileReader));
+
   return Error::success();
 }
 
 /// Return true if the function \p BF should be disassembled.
 static bool shouldDisassemble(const BinaryFunction &BF) {
   if (BF.isPseudo())
     return false;
 
void RewriteInstance::adjustCommandLineOptions() {
   if (BC->HasRelocations && opts::AggregateOnly &&
       !opts::StrictMode.getNumOccurrences()) {
     outs() << "BOLT-INFO: enabling strict relocation mode for aggregation "
               "purposes\n";
     opts::StrictMode = true;
   }
 
   if (BC->isX86() && BC->HasRelocations &&
-      opts::AlignMacroOpFusion == MFT_HOT && !ProfileReader) {
+      opts::AlignMacroOpFusion == MFT_HOT && ProfileReaders.empty()) {
     outs() << "BOLT-INFO: enabling -align-macro-fusion=all since no profile "
               "was specified\n";
     opts::AlignMacroOpFusion = MFT_ALL;
   }
 
   if (!BC->HasRelocations &&
       opts::ReorderFunctions != ReorderFunctions::RT_NONE) {
     errs() << "BOLT-ERROR: function reordering only works when "
void RewriteInstance::handleRelocation(const SectionRef &RelocatedSection,
   } else if (IsToCode || ForceRelocation) {
     BC->addRelocation(Rel.getOffset(), ReferencedSymbol, RType, Addend,
                       ExtractedValue);
   } else {
     LLVM_DEBUG(dbgs() << "BOLT-DEBUG: ignoring relocation from data to data\n");
   }
 }
 
+static bool
+hasProfile(std::vector<std::unique_ptr<ProfileReaderBase>> &ProfileReaders,
+           const BinaryFunction &BF) {
+  return llvm::any_of(ProfileReaders,
+                      [&](std::unique_ptr<ProfileReaderBase> &PR) {
+                        return PR->mayHaveProfileData(BF);
+                      });
+}
+
 void RewriteInstance::selectFunctionsToProcess() {
   // Extend the list of functions to process or skip from a file.
   auto populateFunctionNames = [](cl::opt<std::string> &FunctionNamesFile,
                                   cl::list<std::string> &FunctionNames) {
     if (FunctionNamesFile.empty())
       return;
     std::ifstream FuncsFile(FunctionNamesFile, std::ios::in);
     std::string FuncName;
void RewriteInstance::selectFunctionsToProcess() {
   uint64_t LiteThresholdExecCount = 0;
   if (opts::LiteThresholdPct) {
     if (opts::LiteThresholdPct > 100)
       opts::LiteThresholdPct = 100;
 
     std::vector<const BinaryFunction *> TopFunctions;
     for (auto &BFI : BC->getBinaryFunctions()) {
       const BinaryFunction &Function = BFI.second;
-      if (ProfileReader->mayHaveProfileData(Function))
+      if (hasProfile(ProfileReaders, Function))
         TopFunctions.push_back(&Function);
     }
     llvm::sort(
         TopFunctions, [](const BinaryFunction *A, const BinaryFunction *B) {
           return A->getKnownExecutionCount() < B->getKnownExecutionCount();
         });
 
     size_t Index = TopFunctions.size() * opts::LiteThresholdPct / 100;
if (opts::Lite) {
         if (Match.has_value())
           return true;
         for (const StringRef Name : Function.getNames())
           if (std::optional<StringRef> LTOCommonName = getLTOCommonName(Name))
             if (ReorderFunctionsLTOCommonSet.contains(*LTOCommonName))
               return true;
       }
 
-      if (ProfileReader && !ProfileReader->mayHaveProfileData(Function))
+      if (!hasProfile(ProfileReaders, Function))
         return false;
 
       if (Function.getKnownExecutionCount() < LiteThresholdExecCount)
         return false;
     }
 
     return true;
   };
NamedRegionTimer T("readDebugInfo", "read debug info", TimerGroupName,
                      TimerGroupDesc, opts::TimeRewrite);
   if (!opts::UpdateDebugSections)
     return;
 
   BC->preprocessDebugInfo();
 }
 
 void RewriteInstance::preprocessProfileData() {
-  if (!ProfileReader)
-    return;
-
   NamedRegionTimer T("preprocessprofile", "pre-process profile data",
                      TimerGroupName, TimerGroupDesc, opts::TimeRewrite);
 
+  for (std::unique_ptr<ProfileReaderBase> &PR : ProfileReaders)
+    preprocessProfile(PR);
+}
+
+void RewriteInstance::preprocessProfile(
+    std::unique_ptr<ProfileReaderBase> &ProfileReader) {
   outs() << "BOLT-INFO: pre-processing profile using "
          << ProfileReader->getReaderName() << '\n';
 
   if (BAT->enabledFor(InputFile)) {
     outs() << "BOLT-INFO: profile collection done on a binary already "
               "processed by BOLT\n";
     ProfileReader->setBAT(&*BAT);
   }
 
   if (Error E = ProfileReader->preprocessProfile(*BC.get()))
     report_error("cannot pre-process profile", std::move(E));
 
   if (!BC->hasSymbolsWithFileName() && ProfileReader->hasLocalsWithFileName()) {
     errs() << "BOLT-ERROR: input binary does not have local file symbols "
               "but profile data includes function names with embedded file "
               "names. It appears that the input binary was stripped while a "
               "profiled binary was not\n";
     exit(1);
   }
 }
 
 void RewriteInstance::processProfileDataPreCFG() {
-  if (!ProfileReader)
-    return;
-
   NamedRegionTimer T("processprofile-precfg", "process profile data pre-CFG",
                      TimerGroupName, TimerGroupDesc, opts::TimeRewrite);
 
-  if (Error E = ProfileReader->readProfilePreCFG(*BC.get()))
+  for (std::unique_ptr<ProfileReaderBase> &PR : ProfileReaders)
+    if (Error E = PR->readProfilePreCFG(*BC.get()))
       report_error("cannot read profile pre-CFG", std::move(E));
 }
 
 void RewriteInstance::processProfileData() {
-  if (!ProfileReader)
-    return;
-
   NamedRegionTimer T("processprofile", "process profile data", TimerGroupName,
                      TimerGroupDesc, opts::TimeRewrite);
 
-  if (Error E = ProfileReader->readProfile(*BC.get()))
+  for (std::unique_ptr<ProfileReaderBase> &PR : ProfileReaders)
+    if (Error E = PR->readProfile(*BC.get()))
       report_error("cannot read profile", std::move(E));
 
   if (!opts::SaveProfile.empty()) {
     YAMLProfileWriter PW(opts::SaveProfile);
-    PW.writeProfile(*this);
+    PW.writeProfile(*this, ProfileReaders);
   }
   if (opts::AggregateOnly &&
       opts::ProfileFormat == opts::ProfileFormatKind::PF_YAML) {
     YAMLProfileWriter PW(opts::OutputFilename);
-    PW.writeProfile(*this);
+    PW.writeProfile(*this, ProfileReaders);
   }
 
+  for (std::unique_ptr<ProfileReaderBase> &PR : ProfileReaders) {
     // Release memory used by profile reader.
-  ProfileReader.reset();
+    PR.reset();
+  }
 
   if (opts::AggregateOnly)
     exit(0);
 }
 
 void RewriteInstance::disassembleFunctions() {
   NamedRegionTimer T("disassembleFunctions", "disassemble functions",
                      TimerGroupName, TimerGroupDesc, opts::TimeRewrite);

bolt/lib/Utils/CommandLineOpts.cpp

Instrument("instrument",
                cl::cat(BoltOptCategory));
 
 cl::opt<std::string>
 OutputFilename("o",
   cl::desc("<output file>"),
   cl::Optional,
   cl::cat(BoltOutputCategory));
 
-cl::opt<std::string> PerfData("perfdata", cl::desc("<data file>"), cl::Optional,
+cl::list<std::string> PerfData("perfdata", cl::desc("<data file>"), cl::Optional,
                               cl::cat(AggregatorCategory),
                               cl::sub(cl::SubCommand::getAll()));
 
 static cl::alias
 PerfDataA("p",
   cl::desc("alias for -perfdata"),
   cl::aliasopt(PerfData),
   cl::cat(AggregatorCategory));

bolt/tools/driver/llvm-bolt.cpp

 static cl::OptionCategory *Perf2BoltCategories[] = {&AggregatorCategory,
                                                     &BoltOutputCategory};
 
 static cl::opt<std::string> InputFilename(cl::Positional,
                                           cl::desc("<executable>"),
                                           cl::Required, cl::cat(BoltCategory),
                                           cl::sub(cl::SubCommand::getAll()));
 
-static cl::opt<std::string>
+static cl::list<std::string>
 InputDataFilename("data",
   cl::desc("<data file>"),
   cl::Optional,
   cl::cat(BoltCategory));
 
 static cl::alias
 BoltProfile("b",
   cl::desc("alias for -data"),
   cl::aliasopt(InputDataFilename),
   cl::cat(BoltCategory));
 
-static cl::opt<std::string>
+static cl::list<std::string>
 InputDataFilename2("data2",
   cl::desc("<data file>"),
   cl::Optional,
   cl::cat(BoltCategory));
 
 static cl::opt<std::string>
 InputFilename2(
   cl::Positional,
void perf2boltMode(int argc, char **argv) {
   if (opts::PerfData.empty()) {
     errs() << ToolName << ": expected -perfdata=<filename> option.\n";
     exit(1);
   }
   if (!opts::InputDataFilename.empty()) {
     errs() << ToolName << ": unknown -data option.\n";
     exit(1);
   }
-  if (!sys::fs::exists(opts::PerfData))
-    report_error(opts::PerfData, errc::no_such_file_or_directory);
-  if (!DataAggregator::checkPerfDataMagic(opts::PerfData)) {
-    errs() << ToolName << ": '" << opts::PerfData
+  for (StringRef Filename : opts::PerfData) {
+    if (!sys::fs::exists(Filename))
+      report_error(Filename, errc::no_such_file_or_directory);
+    if (!DataAggregator::checkPerfDataMagic(Filename)) {
+      errs() << ToolName << ": '" << Filename
              << "': expected valid perf.data file.\n";
       exit(1);
     }
+  }
   if (opts::OutputFilename.empty()) {
     errs() << ToolName << ": expected -o=<output file> option.\n";
     exit(1);
   }
   opts::AggregateOnly = true;
 }
 
 void boltDiffMode(int argc, char **argv) {
if (auto *e = dyn_cast<ELFObjectFileBase>(&Binary)) {
       if (!opts::PerfData.empty()) {
         if (!opts::AggregateOnly) {
           errs() << ToolName
                  << ": WARNING: reading perf data directly is unsupported, "
                     "please use "
                     "-aggregate-only or perf2bolt.\n!!! Proceed on your own "
                     "risk. !!!\n";
         }
-        if (Error E = RI.setProfile(opts::PerfData))
-          report_error(opts::PerfData, std::move(E));
-      }
-      if (!opts::InputDataFilename.empty()) {
-        if (Error E = RI.setProfile(opts::InputDataFilename))
-          report_error(opts::InputDataFilename, std::move(E));
-      }
+        for (StringRef Filename : opts::PerfData)
+          if (Error E = RI.setProfile(Filename))
+            report_error(Filename, std::move(E));
+      }
+      for (StringRef Filename : opts::InputDataFilename)
+        if (Error E = RI.setProfile(Filename))
+          report_error(Filename, std::move(E));
       if (opts::AggregateOnly && opts::PerfData.empty()) {
         errs() << ToolName << ": missing required -perfdata option.\n";
         exit(1);
       }
 
       if (Error E = RI.run())
         report_error(opts::InputFilename, std::move(E));
     } else if (auto *O = dyn_cast<MachOObjectFile>(&Binary)) {
       auto MachORIOrErr = MachORewriteInstance::create(O, ToolPath);
       if (Error E = MachORIOrErr.takeError())
         report_error(opts::InputFilename, std::move(E));
       MachORewriteInstance &MachORI = *MachORIOrErr.get();
 
-      if (!opts::InputDataFilename.empty())
-        if (Error E = MachORI.setProfile(opts::InputDataFilename))
-          report_error(opts::InputDataFilename, std::move(E));
+      for (StringRef Filename : opts::InputDataFilename)
+        if (Error E = MachORI.setProfile(Filename))
+          report_error(Filename, std::move(E));
 
       MachORI.run();
     } else {
       report_error(opts::InputFilename, object_error::invalid_file_type);
     }
 
     return EXIT_SUCCESS;
   }
int main(int argc, char **argv) {
   Binary &Binary1 = *BinaryOrErr1.get().getBinary();
   Binary &Binary2 = *BinaryOrErr2.get().getBinary();
   if (auto *ELFObj1 = dyn_cast<ELFObjectFileBase>(&Binary1)) {
     if (auto *ELFObj2 = dyn_cast<ELFObjectFileBase>(&Binary2)) {
       auto RI1OrErr = RewriteInstance::create(ELFObj1, argc, argv, ToolPath);
       if (Error E = RI1OrErr.takeError())
         report_error(opts::InputFilename, std::move(E));
       RewriteInstance &RI1 = *RI1OrErr.get();
-      if (Error E = RI1.setProfile(opts::InputDataFilename))
-        report_error(opts::InputDataFilename, std::move(E));
+      for (StringRef Filename : opts::InputDataFilename)
+        if (Error E = RI1.setProfile(Filename))
+          report_error(Filename, std::move(E));
       auto RI2OrErr = RewriteInstance::create(ELFObj2, argc, argv, ToolPath);
       if (Error E = RI2OrErr.takeError())
         report_error(opts::InputFilename2, std::move(E));
       RewriteInstance &RI2 = *RI2OrErr.get();
-      if (Error E = RI2.setProfile(opts::InputDataFilename2))
-        report_error(opts::InputDataFilename2, std::move(E));
+      for (StringRef Filename : opts::InputDataFilename2)
+        if (Error E = RI2.setProfile(Filename))
+          report_error(Filename, std::move(E));
       outs() << "BOLT-DIFF: *** Analyzing binary 1: " << opts::InputFilename
              << "\n";
-      outs() << "BOLT-DIFF: *** Binary 1 fdata:     " << opts::InputDataFilename
-             << "\n";
+      outs() << "BOLT-DIFF: *** Binary 1 fdata:     ";
+      {
+        ListSeparator LS;
+        for (StringRef Filename : opts::InputDataFilename)
+          outs() << LS << Filename;
+        outs() << "\n";
+      }
       if (Error E = RI1.run())
         report_error(opts::InputFilename, std::move(E));
       outs() << "BOLT-DIFF: *** Analyzing binary 2: " << opts::InputFilename2
              << "\n";
-      outs() << "BOLT-DIFF: *** Binary 2 fdata:     "
-             << opts::InputDataFilename2 << "\n";
+      outs() << "BOLT-DIFF: *** Binary 2 fdata:     ";
+      {
+        ListSeparator LS;
+        for (StringRef Filename : opts::InputDataFilename2)
+          outs() << LS << Filename;
+        outs() << "\n";
+      }
       if (Error E = RI2.run())
         report_error(opts::InputFilename2, std::move(E));
       RI1.compare(RI2);
     } else {
       report_error(opts::InputFilename2, object_error::invalid_file_type);
     }
   } else {
     report_error(opts::InputFilename, object_error::invalid_file_type);
   }
 
   return EXIT_SUCCESS;
 }