Correct the ownership model for sil-opt

Destroying the SIL remark streamer after transferring ownership to LLVM
is frought. For one, the streamer holds the remark file's stream open.
Destroying it early doesn't accomodate sil-opt, which transfers control
to LLVM before running passes that emit remarks.

Instead, just take a reference to the context that the streamer gets
parented onto. If the remarks streamer infrastructure could just hold
the file stream open for us, we wouldn't have to do any of this.

Author: CodaFi

include/swift/SIL/SILModule.h

@@ -523,9 +523,7 @@ class SILModule {
   swift::SILRemarkStreamer *getSILRemarkStreamer() {
     return silRemarkStreamer.get();
   }
-  std::unique_ptr<swift::SILRemarkStreamer> takeSILRemarkStreamer() {
-    return std::move(silRemarkStreamer);
-  }
+
   void installSILRemarkStreamer();
 
   // This is currently limited to VarDecl because the visibility of global

include/swift/SIL/SILRemarkStreamer.h

@@ -26,10 +26,19 @@ namespace swift {
 
 class SILRemarkStreamer {
 private:
+  enum class Owner {
+    SILModule,
+    LLVM,
+  } owner;
+
   /// The underlying LLVM streamer.
   ///
   /// If owned by a SILModule, this will be non-null.
   std::unique_ptr<llvm::remarks::RemarkStreamer> streamer;
+  /// The owning LLVM context.
+  ///
+  /// If owned by LLVM, this will be non-null.
+  llvm::LLVMContext *context;
 
   /// The remark output stream used to record SIL remarks to a file.
   std::unique_ptr<llvm::raw_fd_ostream> remarkStream;

lib/IRGen/IRGen.cpp

@@ -911,8 +911,8 @@ static void initLLVMModule(const IRGenModule &IGM, SILModule &SIL) {
                                                              "standard-library"),
                                          llvm::ConstantAsMetadata::get(Value)}));
 
-  if (auto streamer = SIL.takeSILRemarkStreamer()) {
-    std::move(streamer)->intoLLVMContext(Module->getContext());
+  if (auto *streamer = SIL.getSILRemarkStreamer()) {
+    streamer->intoLLVMContext(Module->getContext());
   }
 }
 

lib/SIL/Utils/SILRemarkStreamer.cpp

@@ -19,20 +19,35 @@ using namespace swift;
 SILRemarkStreamer::SILRemarkStreamer(
     std::unique_ptr<llvm::remarks::RemarkStreamer> &&streamer,
     std::unique_ptr<llvm::raw_fd_ostream> &&stream, const ASTContext &Ctx)
-    : streamer(std::move(streamer)),
+    : owner(Owner::SILModule), streamer(std::move(streamer)), context(nullptr),
       remarkStream(std::move(stream)), ctx(Ctx) { }
 
 llvm::remarks::RemarkStreamer &SILRemarkStreamer::getLLVMStreamer() {
+  switch (owner) {
+  case Owner::SILModule:
+    return *streamer.get();
+  case Owner::LLVM:
+    return *context->getMainRemarkStreamer();
+  }
   return *streamer.get();
 }
 
 const llvm::remarks::RemarkStreamer &
 SILRemarkStreamer::getLLVMStreamer() const {
+  switch (owner) {
+  case Owner::SILModule:
+    return *streamer.get();
+  case Owner::LLVM:
+    return *context->getMainRemarkStreamer();
+  }
   return *streamer.get();
 }
 
 void SILRemarkStreamer::intoLLVMContext(llvm::LLVMContext &Ctx) & {
+  assert(owner == Owner::SILModule);
   Ctx.setMainRemarkStreamer(std::move(streamer));
+  context = &Ctx;
+  owner = Owner::LLVM;
 }
 
 std::unique_ptr<SILRemarkStreamer>

tools/sil-opt/SILOpt.cpp

@@ -461,7 +461,7 @@ int main(int argc, char **argv) {
   if (CI.getSILModule())
     CI.getSILModule()->setSerializeSILAction([]{});
 
-  if (RemarksFilename != "") {
+  if (!RemarksFilename.empty()) {
     llvm::Expected<llvm::remarks::Format> formatOrErr =
         llvm::remarks::parseFormat(RemarksFormat);
     if (llvm::Error E = formatOrErr.takeError()) {