[opt-remark] Have OptEmitter store a SILFunction instead of a SILModule.

In all of these cases, we already had a SILFunction and were just grabbing its
SILModule instead of passing it in. So this is just an NFC change.

The reason why I am doing this is so that I can force emit opt-remarks on
functions with the semantics attribute "optremark", so I need to be able to
access the SILFunction in the optimization remark infrastructure.

Author: gottesmm

include/swift/SIL/OptimizationRemark.h

@@ -250,7 +250,7 @@ struct RemarkMissed : public Remark<RemarkMissed> {
 /// Used to emit the remarks.  Passes reporting remarks should create an
 /// instance of this.
 class Emitter {
-  SILModule &module;
+  SILFunction &fn;
   std::string passName;
   bool passedEnabled;
   bool missedEnabled;
@@ -264,7 +264,7 @@ class Emitter {
   template <typename RemarkT> bool isEnabled();
 
 public:
-  Emitter(StringRef passName, SILModule &m);
+  Emitter(StringRef passName, SILFunction &fn);
 
   /// Take a lambda that returns a remark which will be emitted.  The
   /// lambda is not evaluated unless remarks are enabled.  Second argument is
@@ -273,7 +273,7 @@ class Emitter {
   void emit(T remarkBuilder, decltype(remarkBuilder()) * = nullptr) {
     using RemarkT = decltype(remarkBuilder());
     // Avoid building the remark unless remarks are enabled.
-    if (isEnabled<RemarkT>() || module.getSILRemarkStreamer()) {
+    if (isEnabled<RemarkT>() || fn.getModule().getSILRemarkStreamer()) {
       auto rb = remarkBuilder();
       rb.setPassName(passName);
       emit(rb);
@@ -287,8 +287,9 @@ class Emitter {
                           decltype(remarkBuilder()) * = nullptr) {
     using RemarkT = decltype(remarkBuilder());
     // Avoid building the remark unless remarks are enabled.
-    bool emitRemark = emitter && (emitter->isEnabled<RemarkT>() ||
-                                  emitter->module.getSILRemarkStreamer());
+    bool emitRemark =
+        emitter && (emitter->isEnabled<RemarkT>() ||
+                    emitter->fn.getModule().getSILRemarkStreamer());
     // Same for DEBUG.
     bool shouldEmitDebug = false;
 #ifndef NDEBUG

lib/SIL/Utils/OptimizationRemark.cpp

@@ -144,15 +144,15 @@ std::string Remark<DerivedT>::getDebugMsg() const {
   return stream.str();
 }
 
-Emitter::Emitter(StringRef passName, SILModule &m)
-    : module(m), passName(passName),
+Emitter::Emitter(StringRef passName, SILFunction &fn)
+    : fn(fn), passName(passName),
       passedEnabled(
-          m.getASTContext().LangOpts.OptimizationRemarkPassedPattern &&
-          m.getASTContext().LangOpts.OptimizationRemarkPassedPattern->match(
+          fn.getASTContext().LangOpts.OptimizationRemarkPassedPattern &&
+          fn.getASTContext().LangOpts.OptimizationRemarkPassedPattern->match(
               passName)),
       missedEnabled(
-          m.getASTContext().LangOpts.OptimizationRemarkMissedPattern &&
-          m.getASTContext().LangOpts.OptimizationRemarkMissedPattern->match(
+          fn.getASTContext().LangOpts.OptimizationRemarkMissedPattern &&
+          fn.getASTContext().LangOpts.OptimizationRemarkMissedPattern->match(
               passName)) {}
 
 /// The user has passed us an instruction that for some reason has a source loc
@@ -240,10 +240,12 @@ SourceLoc swift::OptRemark::inferOptRemarkSourceLoc(
 }
 
 template <typename RemarkT, typename... ArgTypes>
-static void emitRemark(SILModule &module, const Remark<RemarkT> &remark,
+static void emitRemark(SILFunction &fn, const Remark<RemarkT> &remark,
                        Diag<ArgTypes...> id, bool diagEnabled) {
   if (remark.getLocation().isInvalid())
     return;
+
+  auto &module = fn.getModule();
   if (auto *remarkStreamer = module.getSILRemarkStreamer())
     remarkStreamer->emit(remark);
 
@@ -273,13 +275,11 @@ static void emitRemark(SILModule &module, const Remark<RemarkT> &remark,
 }
 
 void Emitter::emit(const RemarkPassed &remark) {
-  emitRemark(module, remark, diag::opt_remark_passed,
-             isEnabled<RemarkPassed>());
+  emitRemark(fn, remark, diag::opt_remark_passed, isEnabled<RemarkPassed>());
 }
 
 void Emitter::emit(const RemarkMissed &remark) {
-  emitRemark(module, remark, diag::opt_remark_missed,
-             isEnabled<RemarkMissed>());
+  emitRemark(fn, remark, diag::opt_remark_missed, isEnabled<RemarkMissed>());
 }
 
 void Emitter::emitDebug(const RemarkPassed &remark) {

lib/SILOptimizer/Transforms/Devirtualizer.cpp

@@ -60,7 +60,7 @@ class Devirtualizer : public SILFunctionTransform {
 void Devirtualizer::devirtualizeAppliesInFunction(SILFunction &F,
                                                   ClassHierarchyAnalysis *CHA) {
   llvm::SmallVector<ApplySite, 8> NewApplies;
-  OptRemark::Emitter ORE(DEBUG_TYPE, F.getModule());
+  OptRemark::Emitter ORE(DEBUG_TYPE, F);
 
   SmallVector<ApplySite, 16> Applies;
   for (auto &BB : F) {

lib/SILOptimizer/Transforms/GenericSpecializer.cpp

@@ -61,7 +61,7 @@ bool GenericSpecializer::specializeAppliesInFunction(SILFunction &F) {
   SILOptFunctionBuilder FunctionBuilder(*this);
   DeadInstructionSet DeadApplies;
   llvm::SmallSetVector<SILInstruction *, 8> Applies;
-  OptRemark::Emitter ORE(DEBUG_TYPE, F.getModule());
+  OptRemark::Emitter ORE(DEBUG_TYPE, F);
 
   bool Changed = false;
   for (auto &BB : F) {

lib/SILOptimizer/Transforms/OptRemarkGenerator.cpp

@@ -35,9 +35,9 @@ struct OptRemarkGeneratorInstructionVisitor
   RCIdentityFunctionInfo &rcfi;
   OptRemark::Emitter ORE;
 
-  OptRemarkGeneratorInstructionVisitor(SILModule &mod,
+  OptRemarkGeneratorInstructionVisitor(SILFunction &fn,
                                        RCIdentityFunctionInfo &rcfi)
-      : mod(mod), rcfi(rcfi), ORE(DEBUG_TYPE, mod) {}
+      : mod(fn.getModule()), rcfi(rcfi), ORE(DEBUG_TYPE, fn) {}
 
   void visitStrongRetainInst(StrongRetainInst *sri);
   void visitStrongReleaseInst(StrongReleaseInst *sri);
@@ -174,13 +174,13 @@ class OptRemarkGenerator : public SILFunctionTransform {
   ~OptRemarkGenerator() override {}
 
   bool isOptRemarksEnabled() {
+    auto *fn = getFunction();
     // TODO: Put this on LangOpts as a helper.
-    auto &langOpts = getFunction()->getASTContext().LangOpts;
+    auto &langOpts = fn->getASTContext().LangOpts;
 
-    // If we have a remark streamer, emit everything.
     return bool(langOpts.OptimizationRemarkMissedPattern) ||
            bool(langOpts.OptimizationRemarkPassedPattern) ||
-           getFunction()->getModule().getSILRemarkStreamer();
+           fn->getModule().getSILRemarkStreamer();
   }
 
   /// The entry point to the transformation.
@@ -191,7 +191,7 @@ class OptRemarkGenerator : public SILFunctionTransform {
     auto *fn = getFunction();
     LLVM_DEBUG(llvm::dbgs() << "Visiting: " << fn->getName() << "\n");
     auto &rcfi = *getAnalysis<RCIdentityAnalysis>()->get(fn);
-    OptRemarkGeneratorInstructionVisitor visitor(fn->getModule(), rcfi);
+    OptRemarkGeneratorInstructionVisitor visitor(*fn, rcfi);
     for (auto &block : *fn) {
       for (auto &inst : block) {
         visitor.visit(&inst);

lib/SILOptimizer/Transforms/PerformanceInliner.cpp

@@ -1008,7 +1008,7 @@ class SILPerformanceInlinerPass : public SILFunctionTransform {
     DominanceAnalysis *DA = PM->getAnalysis<DominanceAnalysis>();
     SILLoopAnalysis *LA = PM->getAnalysis<SILLoopAnalysis>();
     SideEffectAnalysis *SEA = PM->getAnalysis<SideEffectAnalysis>();
-    OptRemark::Emitter ORE(DEBUG_TYPE, getFunction()->getModule());
+    OptRemark::Emitter ORE(DEBUG_TYPE, *getFunction());
 
     if (getOptions().InlineThreshold == 0) {
       return;

lib/SILOptimizer/Transforms/SpeculativeDevirtualizer.cpp

@@ -616,7 +616,7 @@ namespace {
         }
       }
 
-      OptRemark::Emitter ORE(DEBUG_TYPE, CurFn.getModule());
+      OptRemark::Emitter ORE(DEBUG_TYPE, CurFn);
       // Go over the collected calls and try to insert speculative calls.
       for (auto AI : ToSpecialize)
         Changed |= tryToSpeculateTarget(AI, CHA, ORE);