Inliner refactoring: consolidate logging, reporting and dumping

With this change the responsibility for dumping, logging, and reporting
inline decisions is moved into the JitInlineResult class instead of being
distributed throughout the code base. This insures all the relevant inline
information is handled in a consistent manner.

The JitInlineResult is updated to hold a compiler instance and now
requires a context string describing the what the jit is doing as it evaluates
an inline candidate. There are 4 distinct contexts in use currently.

Author: AndyAyersMS

src/jit/compiler.cpp

@@ -4282,7 +4282,6 @@ int           Compiler::compCompile(CORINFO_METHOD_HANDLE methodHnd,
     {
         if (compIsForInlining())
         {
-            JITLOG((LL_INFO1000000, INLINER_FAILED "Inlinee marked as skipped.\n"));
             compInlineResult->setNever("Inlinee marked as skipped");
         }
         return CORJIT_SKIPPED;
@@ -4891,7 +4890,7 @@ int           Compiler::compCompileHelper (CORINFO_MODULE_HANDLE            clas
             if (opts.eeFlags & CORJIT_FLG_PREJIT)
             {
                 // Cache inlining hint during NGen to avoid touching bodies of non-inlineable methods at runtime
-                JitInlineResult trialResult(info.compCompHnd, nullptr, methodHnd);
+                JitInlineResult trialResult(this, nullptr, methodHnd, "prejit1");
                 impCanInlineIL(methodHnd, methodInfo, forceInline, &trialResult);
                 if (trialResult.isFailure())
                 {
@@ -4937,7 +4936,7 @@ int           Compiler::compCompileHelper (CORINFO_MODULE_HANDLE            clas
             assert(compNativeSizeEstimate != NATIVE_SIZE_INVALID); 
 
             int callsiteNativeSizeEstimate = impEstimateCallsiteNativeSize(methodInfo);
-            JitInlineResult trialResult(info.compCompHnd, nullptr, methodHnd);
+            JitInlineResult trialResult(this, nullptr, methodHnd, "prejit2");
 
             impCanInlineNative(callsiteNativeSizeEstimate, 
                                compNativeSizeEstimate,
@@ -5000,7 +4999,6 @@ int           Compiler::compCompileHelper (CORINFO_MODULE_HANDLE            clas
             (fgBBcount > 5) &&
             !forceInline)
         {
-            JITLOG((LL_INFO1000000, INLINER_FAILED "Too many basic blocks in the inlinee.\n"));
             compInlineResult->setNever("Too many basic blocks in the inlinee");
             goto _Next;
         }
@@ -9750,3 +9748,48 @@ HelperCallProperties Compiler::s_helperCallProperties;
 
 /*****************************************************************************/
 /*****************************************************************************/
+
+//------------------------------------------------------------------------
+// report: Dump, log, and report information about an inline decision.
+//
+// Notes:
+//    
+//    Called (automatically via the JitInlineResult dtor) when the inliner
+//    is done evaluating a candidate.
+//
+//    Dumps state of the inline candidate, and if a decision was reached
+//    sends it to the log and reports the decision back to the EE. 
+//    
+//    All this can be suppressed if desired by calling setReported() before 
+//    the JitInlineResult goes out of scope.
+
+void JitInlineResult::report() 
+{
+    // User may have suppressed reporting via setReported(). If so, do nothing.
+    if (inlReported)
+    {
+        return;
+    }
+
+    inlReported = true;
+
+#ifdef DEBUG
+
+    const char* format = "INLINER: during '%s' result '%s' reason '%s' for '%s' calling '%s'\n";
+    const char* caller = (inlInliner == nullptr) ? "n/a" : inlCompiler->eeGetMethodFullName(inlInliner);
+    const char* callee = (inlInlinee == nullptr) ? "n/a" : inlCompiler->eeGetMethodFullName(inlInlinee);
+
+    JITDUMP(format, inlContext, resultString(), inlReason, caller, callee);
+
+#endif // DEBUG
+
+    if (isDecided()) 
+    {
+        JITLOG_THIS(inlCompiler, (LL_INFO100000, format, inlContext, resultString(), inlReason, caller, callee));
+        COMP_HANDLE comp = inlCompiler->info.compCompHnd;
+        comp->reportInliningDecision(inlInliner, inlInlinee, result(), inlReason);
+    }
+}
+
+    
+

src/jit/compiler.h

@@ -878,14 +878,16 @@ class JitInlineResult
 public:
 
     // Construct a new JitInlineResult.
-    JitInlineResult(COMP_HANDLE            compiler,
+    JitInlineResult(Compiler*              compiler,
                     CORINFO_METHOD_HANDLE  inliner,
-                    CORINFO_METHOD_HANDLE  inlinee)
-        : inlComp(compiler)
+                    CORINFO_METHOD_HANDLE  inlinee,
+                    const char*            context)
+        : inlCompiler(compiler)
         , inlDecision(InlineDecision::UNDECIDED)
         , inlInliner(inliner)
         , inlInlinee(inlinee)
         , inlReason(nullptr)
+        , inlContext(context)
         , inlReported(false)
     {
         // empty
@@ -910,6 +912,26 @@ class JitInlineResult
         }
     }
 
+    // Translate into string for dumping
+    const char* resultString() const 
+    { 
+        switch (inlDecision) {
+            case InlineDecision::SUCCESS:
+                return "success";
+            case InlineDecision::FAILURE:
+                return "failed this call site";
+            case InlineDecision::NEVER:
+                return "failed this callee";
+            case InlineDecision::CANDIDATE:
+                return "candidate";            
+            case InlineDecision::UNDECIDED:
+                return "undecided";
+            default:
+                assert(!"Unexpected: interim inline result");
+                unreached();
+        }
+    }
+
     // True if this definitely a failed inline candidate
     bool isFailure() const 
     { 
@@ -1012,7 +1034,7 @@ class JitInlineResult
         setCommon(InlineDecision::NEVER, reason);
     }
 
-    // Report decision, if necessary.
+    // Report/log/dump decision as appropriate
     ~JitInlineResult() 
     {
         report();
@@ -1021,7 +1043,7 @@ class JitInlineResult
     const char * reason() const { return inlReason; }
 
     // setReported indicates that this particular result doesn't need
-    // to be reported back to the runtime, either becaus the runtime
+    // to be reported back to the runtime, either because the runtime
     // already knows, or we weren't actually inlining yet.
     void setReported() { inlReported = true; }
 
@@ -1038,21 +1060,15 @@ class JitInlineResult
         inlDecision = decision;
         inlReason = reason;
     }
-    
-    void report() 
-    {
-        if (!inlReported && isDecided()) 
-        {
-            inlComp->reportInliningDecision(inlInliner, inlInlinee, result(), inlReason);
-        }
-        inlReported = true;
-    }
-    
-    COMP_HANDLE             inlComp;
+
+    void report();
+
+    Compiler*               inlCompiler;
     InlineDecision          inlDecision;
     CORINFO_METHOD_HANDLE   inlInliner;
     CORINFO_METHOD_HANDLE   inlInlinee;
     const char*             inlReason;
+    const char*             inlContext;
     bool                    inlReported;
 };
 

src/jit/flowgraph.cpp

@@ -22053,9 +22053,6 @@ void       Compiler::fgInvokeInlineeCompiler(GenTreeCall* call,
         if (!(info.compCompHnd->initClass(NULL /* field */, fncHandle /* method */,
                 inlineCandidateInfo->exactContextHnd /* context */) & CORINFO_INITCLASS_INITIALIZED))
         {
-            JITLOG((LL_INFO100000, INLINER_FAILED "Could not complete class init side effect: "
-                    "%s called by %s\n",
-                    eeGetMethodFullName(fncHandle), info.compFullName));
             inlineResult->setNever("Failed class init side-effect");
             return;
         }