[LTO] Allow pass remarks with hotness to be set when emitting to stderr

[tejohnson]

Summary

Set setDiagnosticsHotnessRequested before the early exit check for a
diagnostic output file, so that pass remarks with hotness works when
emitting pass remarks to stderr (e.g. via -pass-remarks=.).

Also fix the llvm-lto2 diagnistic handler so that it only calls exit(1)
when the diagnistic is an error type. Otherwise the new test invocation
of llvm-lto2 with -pass-remarks causes it to fail. The new code is
consistent with the diagnostic handler elsewhere (e.g. on the
LLVMContext).

[pcc]

LGTM

llvm/trunk/lib/LTO/LTO.cpp

Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache) {
 
   return BackendProc->wait();
 }
 
 Expected<std::unique_ptr<ToolOutputFile>>
 lto::setupOptimizationRemarks(LLVMContext &Context,
                               StringRef LTORemarksFilename,
                               bool LTOPassRemarksWithHotness, int Count) {
+  if (LTOPassRemarksWithHotness)
+    Context.setDiagnosticsHotnessRequested(true);
   if (LTORemarksFilename.empty())
     return nullptr;
 
   std::string Filename = LTORemarksFilename;
   if (Count != -1)
     Filename += ".thin." + llvm::utostr(Count) + ".yaml";
 
   std::error_code EC;
   auto DiagnosticFile =
       llvm::make_unique<ToolOutputFile>(Filename, EC, sys::fs::F_None);
   if (EC)
     return errorCodeToError(EC);
   Context.setDiagnosticsOutputFile(
       llvm::make_unique<yaml::Output>(DiagnosticFile->os()));
-  if (LTOPassRemarksWithHotness)
-    Context.setDiagnosticsHotnessRequested(true);
   DiagnosticFile->keep();
   return std::move(DiagnosticFile);
 }

llvm/trunk/test/LTO/Resolution/X86/diagnostic-handler-remarks-with-hotness.ll

 ; RUN: llvm-as < %s >%t.bc
 
+; Check pass remarks emitted to YAML file
 ; RUN: rm -f %t.yaml
 ; RUN: llvm-lto2 run -pass-remarks-output=%t.yaml \
 ; RUN:           -pass-remarks-with-hotness \
 ; RUN:           -r %t.bc,tinkywinky,p \
 ; RUN:           -r %t.bc,patatino,px \
 ; RUN:           -r %t.bc,main,px -o %t.o %t.bc
 ; RUN: cat %t.yaml | FileCheck %s -check-prefix=YAML
 
+; Check pass remarks emitted to stderr
+; RUN: llvm-lto2 run -pass-remarks=inline \
+; RUN:           -pass-remarks-with-hotness \
+; RUN:           -r %t.bc,tinkywinky,p \
+; RUN:           -r %t.bc,patatino,px \
+; RUN:           -r %t.bc,main,px -o %t.o %t.bc 2>&1 | FileCheck %s
+
 ; YAML: --- !Passed
 ; YAML-NEXT: Pass:            inline
 ; YAML-NEXT: Name:            Inlined
 ; YAML-NEXT: Function:        main
 ; YAML-NEXT: Hotness:         300
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - Callee:          tinkywinky
 ; YAML-NEXT:   - String:          ' inlined into '
 ; YAML-NEXT:   - Caller:          main
 ; YAML-NEXT:   - String:          ' with cost='
 ; YAML-NEXT:   - Cost:            '-15000'
 ; YAML-NEXT:   - String:          ' (threshold='
 ; YAML-NEXT:   - Threshold:       '337'
 ; YAML-NEXT:   - String:          ')'
 ; YAML-NEXT: ...
 
+; CHECK: tinkywinky inlined into main with cost=-15000 (threshold=337) (hotness: 300)
+
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-scei-ps4"
 
 declare i32 @patatino()
 
 define i32 @tinkywinky() {
   %a = call i32 @patatino()
   ret i32 %a
 }
 
 define i32 @main() !prof !0 {
   %i = call i32 @tinkywinky()
   ret i32 %i
 }
 
 !0 = !{!"function_entry_count", i64 300}

llvm/trunk/tools/llvm-lto2/llvm-lto2.cpp

static int run(int argc, char **argv) {
 
   std::vector<std::unique_ptr<MemoryBuffer>> MBs;
 
   Config Conf;
   Conf.DiagHandler = [](const DiagnosticInfo &DI) {
     DiagnosticPrinterRawOStream DP(errs());
     DI.print(DP);
     errs() << '\n';
+    if (DI.getSeverity() == DS_Error)
       exit(1);
   };
 
   Conf.CPU = MCPU;
   Conf.Options = InitTargetOptionsFromCodeGenFlags();
   Conf.MAttrs = MAttrs;
   if (auto RM = getRelocModel())
     Conf.RelocModel = *RM;
   Conf.CodeModel = getCodeModel();