[NFC] Refactor the construction of SILRemarksStreamer

The Remarks Streamer's installation seemed a bit overly complex, so simplify it in a few places:

* Refactor sil-opt to install the remarks options into the SILOptions for the SILModule

This reduces the parameter bloat in createSILRemarkStreamer. All of this data is freely derivable from the SILModule alone.

* Refactor createSILRemarkStreamer into SILRemarkStreamer::create

With the new reduction in parameters, we can hide the internal constructor and introduce a smart constructor that vends a unique pointer to clients.

* setSILRemarkStreamer -> installSILRemarkStreamer

Since the information to create a streamer is now entirely derivable from a module, remove a layer of abstraction and have the module directly construct a streamer for itself.

* Give SILRemarkStreamer its own LLVMContext

The remarks streamer just needs scratch space. It's not actually "installed" in a given context. There no reason to use Swift's Global Context here.

* Give the SILRemarkStreamer ownership of the underlying file stream

The SILModule didn't actually use this member, and it seems like somebody needs to own it, so just give it to the remarks streamer directly.

Author: CodaFi

include/swift/SIL/SILRemarkStreamer.h

@@ -25,31 +25,39 @@
 namespace swift {
 
 class SILRemarkStreamer {
-  llvm::remarks::RemarkStreamer &llvmStreamer;
+private:
+  /// The \c LLVMContext the underlying streamer uses for scratch space.
+  std::unique_ptr<llvm::LLVMContext> streamerContext;
+  /// The remark output stream used to record SIL remarks to a file.
+  std::unique_ptr<llvm::raw_fd_ostream> remarkStream;
+
   // Source manager for resolving source locations.
-  const SourceManager &srcMgr;
+  const ASTContext &ctx;
   /// Convert diagnostics into LLVM remark objects.
   /// The lifetime of the members of the result is bound to the lifetime of
   /// the SIL remarks.
   template <typename RemarkT>
   llvm::remarks::Remark
   toLLVMRemark(const OptRemark::Remark<RemarkT> &remark) const;
 
+  SILRemarkStreamer(std::unique_ptr<llvm::remarks::RemarkStreamer> &&streamer,
+                    std::unique_ptr<llvm::raw_fd_ostream> &&stream,
+                    const ASTContext &Ctx);
+
+public:
+  static std::unique_ptr<SILRemarkStreamer> create(SILModule &silModule);
+
 public:
-  SILRemarkStreamer(llvm::remarks::RemarkStreamer &llvmStreamer,
-                    const SourceManager &srcMgr)
-      : llvmStreamer(llvmStreamer), srcMgr(srcMgr) {}
+  llvm::remarks::RemarkStreamer &getLLVMStreamer();
+  const llvm::remarks::RemarkStreamer &getLLVMStreamer() const;
+
+  const ASTContext &getASTContext() const { return ctx; }
+
   /// Emit a remark through the streamer.
   template <typename RemarkT>
   void emit(const OptRemark::Remark<RemarkT> &remark);
 };
 
-std::pair<std::unique_ptr<llvm::raw_fd_ostream>,
-          std::unique_ptr<SILRemarkStreamer>>
-createSILRemarkStreamer(SILModule &srcMgr, StringRef filename, StringRef passes,
-                        llvm::remarks::Format format,
-                        DiagnosticEngine &diagEngine, SourceManager &sourceMgr);
-
 // Implementation for template member functions.
 
 // OptRemark type -> llvm::remarks::Type
@@ -80,24 +88,26 @@ llvm::remarks::Remark SILRemarkStreamer::toLLVMRemark(
   llvmRemark.PassName = optRemark.getPassName();
   llvmRemark.RemarkName = optRemark.getIdentifier();
   llvmRemark.FunctionName = optRemark.getDemangledFunctionName();
-  llvmRemark.Loc = toRemarkLocation(optRemark.getLocation(), srcMgr);
+  llvmRemark.Loc =
+      toRemarkLocation(optRemark.getLocation(), getASTContext().SourceMgr);
 
   for (const OptRemark::Argument &arg : optRemark.getArgs()) {
     llvmRemark.Args.emplace_back();
     llvmRemark.Args.back().Key = arg.key;
     llvmRemark.Args.back().Val = arg.val;
-    llvmRemark.Args.back().Loc = toRemarkLocation(arg.loc, srcMgr);
+    llvmRemark.Args.back().Loc =
+        toRemarkLocation(arg.loc, getASTContext().SourceMgr);
   }
 
   return llvmRemark;
 }
 
 template <typename RemarkT>
 void SILRemarkStreamer::emit(const OptRemark::Remark<RemarkT> &optRemark) {
-  if (!llvmStreamer.matchesFilter(optRemark.getPassName()))
+  if (!getLLVMStreamer().matchesFilter(optRemark.getPassName()))
     return;
 
-  return llvmStreamer.getSerializer().emit(toLLVMRemark(optRemark));
+  return getLLVMStreamer().getSerializer().emit(toLLVMRemark(optRemark));
 }
 
 } // namespace swift

lib/FrontendTool/FrontendTool.cpp

@@ -41,7 +41,6 @@
 #include "swift/Basic/Edit.h"
 #include "swift/Basic/FileSystem.h"
 #include "swift/Basic/JSONSerialization.h"
-#include "swift/Basic/LLVMContext.h"
 #include "swift/Basic/LLVMInitialize.h"
 #include "swift/Basic/Platform.h"
 #include "swift/Basic/PrettyStackTrace.h"
@@ -1557,7 +1556,6 @@ static bool performCompileStepsPostSILGen(
   FrontendOptions opts = Invocation.getFrontendOptions();
   FrontendOptions::ActionType Action = opts.RequestedAction;
   const ASTContext &Context = Instance.getASTContext();
-  const SILOptions &SILOpts = Invocation.getSILOptions();
   const IRGenOptions &IRGenOpts = Invocation.getIRGenOptions();
 
   Optional<BufferIndirectlyCausingDiagnosticRAII> ricd;
@@ -1581,10 +1579,7 @@ static bool performCompileStepsPostSILGen(
     return Context.hadError();
   }
 
-  auto pair = createSILRemarkStreamer(
-      *SM, SILOpts.OptRecordFile, SILOpts.OptRecordPasses,
-      SILOpts.OptRecordFormat, Instance.getDiags(), Instance.getSourceMgr());
-  SM->setSILRemarkStreamer(std::move(pair.first), std::move(pair.second));
+  SM->installSILRemarkStreamer();
 
   // This is the action to be used to serialize SILModule.
   // It may be invoked multiple times, but it will perform

lib/SIL/IR/SILModule.cpp

@@ -28,6 +28,7 @@
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <functional>
@@ -698,11 +699,9 @@ void SILModule::serialize() {
   setSerialized();
 }
 
-void SILModule::setSILRemarkStreamer(
-    std::unique_ptr<llvm::raw_fd_ostream> &&remarkStream,
-    std::unique_ptr<swift::SILRemarkStreamer> &&remarkStreamer) {
-  silRemarkStream = std::move(remarkStream);
-  silRemarkStreamer = std::move(remarkStreamer);
+void SILModule::installSILRemarkStreamer() {
+  assert(!silRemarkStreamer && "SIL Remark Streamer is already installed!");
+  silRemarkStreamer = SILRemarkStreamer::create(*this);
 }
 
 bool SILModule::isStdlibModule() const {

lib/SIL/Utils/SILRemarkStreamer.cpp

@@ -12,27 +12,42 @@
 
 #include "swift/SIL/SILRemarkStreamer.h"
 #include "swift/AST/DiagnosticsFrontend.h"
-#include "swift/Basic/LLVMContext.h"
 #include "llvm/IR/LLVMContext.h"
 
 using namespace swift;
 
-std::pair<std::unique_ptr<llvm::raw_fd_ostream>,
-          std::unique_ptr<SILRemarkStreamer>>
-swift::createSILRemarkStreamer(SILModule &silModule, StringRef filename,
-                               StringRef passes, llvm::remarks::Format format,
-                               DiagnosticEngine &diagEngine,
-                               SourceManager &sourceMgr) {
+SILRemarkStreamer::SILRemarkStreamer(
+    std::unique_ptr<llvm::remarks::RemarkStreamer> &&streamer,
+    std::unique_ptr<llvm::raw_fd_ostream> &&stream, const ASTContext &Ctx)
+    : streamerContext(std::make_unique<llvm::LLVMContext>()),
+      remarkStream(std::move(stream)), ctx(Ctx) {
+  streamerContext->setMainRemarkStreamer(std::move(streamer));
+}
+
+llvm::remarks::RemarkStreamer &SILRemarkStreamer::getLLVMStreamer() {
+  return *streamerContext->getMainRemarkStreamer();
+}
+
+const llvm::remarks::RemarkStreamer &
+SILRemarkStreamer::getLLVMStreamer() const {
+  return *streamerContext->getMainRemarkStreamer();
+}
+
+std::unique_ptr<SILRemarkStreamer>
+SILRemarkStreamer::create(SILModule &silModule) {
+  StringRef filename = silModule.getOptions().OptRecordFile;
+  const auto format = silModule.getOptions().OptRecordFormat;
   if (filename.empty())
-    return {nullptr, nullptr};
+    return nullptr;
 
+  auto &diagEngine = silModule.getASTContext().Diags;
   std::error_code errorCode;
   auto file = std::make_unique<llvm::raw_fd_ostream>(filename, errorCode,
                                                      llvm::sys::fs::F_None);
   if (errorCode) {
     diagEngine.diagnose(SourceLoc(), diag::cannot_open_file, filename,
                         errorCode.message());
-    return {nullptr, nullptr};
+    return nullptr;
   }
 
   llvm::Expected<std::unique_ptr<llvm::remarks::RemarkSerializer>>
@@ -41,23 +56,24 @@ swift::createSILRemarkStreamer(SILModule &silModule, StringRef filename,
   if (llvm::Error err = remarkSerializerOrErr.takeError()) {
     diagEngine.diagnose(SourceLoc(), diag::error_creating_remark_serializer,
                         toString(std::move(err)));
-    return {nullptr, nullptr};
+    return nullptr;
   }
 
   auto mainRS = std::make_unique<llvm::remarks::RemarkStreamer>(
       std::move(*remarkSerializerOrErr), filename);
-  llvm::remarks::RemarkStreamer &mainRemarkStreamer = *mainRS;
-  getGlobalLLVMContext().setMainRemarkStreamer(std::move(mainRS));
 
+  const auto passes = silModule.getOptions().OptRecordPasses;
   if (!passes.empty()) {
-    if (llvm::Error err = mainRemarkStreamer.setFilter(passes)) {
+    if (llvm::Error err = mainRS->setFilter(passes)) {
       diagEngine.diagnose(SourceLoc(), diag::error_creating_remark_serializer,
                           toString(std::move(err)));
-      return {nullptr, nullptr};
+      return nullptr;
     }
   }
 
-  auto remarkStreamer =
-      std::make_unique<SILRemarkStreamer>(mainRemarkStreamer, sourceMgr);
-  return {std::move(file), std::move(remarkStreamer)};
+  // N.B. We should be able to use std::make_unique here, but I prefer correctly
+  // encapsulating the constructor over elegance.
+  // Besides, this isn't going to throw an exception.
+  return std::unique_ptr<SILRemarkStreamer>(new SILRemarkStreamer(
+      std::move(mainRS), std::move(file), silModule.getASTContext()));
 }

tools/sil-opt/SILOpt.cpp

@@ -20,7 +20,6 @@
 #include "swift/AST/SILOptions.h"
 #include "swift/Basic/FileTypes.h"
 #include "swift/Basic/LLVMInitialize.h"
-#include "swift/Basic/LLVMContext.h"
 #include "swift/Frontend/DiagnosticVerifier.h"
 #include "swift/Frontend/Frontend.h"
 #include "swift/Frontend/PrintingDiagnosticConsumer.h"
@@ -363,6 +362,8 @@ int main(int argc, char **argv) {
   SILOpts.VerifySILOwnership = !DisableSILOwnershipVerifier;
   SILOpts.StripOwnershipAfterSerialization =
       EnableOwnershipLoweringAfterDiagnostics;
+  SILOpts.OptRecordFile = RemarksFilename;
+  SILOpts.OptRecordPasses = RemarksPasses;
 
   SILOpts.VerifyExclusivity = VerifyExclusivity;
   if (EnforceExclusivity.getNumOccurrences() != 0) {
@@ -461,23 +462,19 @@ int main(int argc, char **argv) {
     CI.getSILModule()->setSerializeSILAction([]{});
 
   if (RemarksFilename != "") {
-    llvm::remarks::Format remarksFormat = llvm::remarks::Format::YAML;
     llvm::Expected<llvm::remarks::Format> formatOrErr =
         llvm::remarks::parseFormat(RemarksFormat);
     if (llvm::Error E = formatOrErr.takeError()) {
       CI.getDiags().diagnose(SourceLoc(),
                              diag::error_creating_remark_serializer,
                              toString(std::move(E)));
       HadError = true;
+      SILOpts.OptRecordFormat = llvm::remarks::Format::YAML;
     } else {
-      remarksFormat = *formatOrErr;
+      SILOpts.OptRecordFormat = *formatOrErr;
     }
 
-    auto Pair = createSILRemarkStreamer(*CI.getSILModule(), RemarksFilename,
-                                        RemarksPasses, remarksFormat,
-                                        CI.getDiags(), CI.getSourceMgr());
-    CI.getSILModule()->setSILRemarkStreamer(std::move(Pair.first),
-                                            std::move(Pair.second));
+    CI.getSILModule()->installSILRemarkStreamer();
   }
 
   if (OptimizationGroup == OptGroup::Diagnostics) {