[BOLT] Remove unnecessary diagnostics

[maksfb]

Summary

When optimizations passes do not change anything, skip their diagnostics
output. NFC otherwise.

bolt/lib/Passes/BinaryPasses.cpp

LLVM_DEBUG({
       }
     });
     std::tie(Count, Bytes) = Function.eraseInvalidBBs();
     DeletedBlocks += Count;
     DeletedBytes += Bytes;
     if (Count) {
       Modified.insert(&Function);
       if (opts::Verbosity > 0)
-        outs() << "BOLT-INFO: Removed " << Count
+        outs() << "BOLT-INFO: removed " << Count
                << " dead basic block(s) accounting for " << Bytes
                << " bytes in function " << Function << '\n';
     }
   }
 }
 
 void EliminateUnreachableBlocks::runOnFunctions(BinaryContext &BC) {
   for (auto &It : BC.getBinaryFunctions()) {
     BinaryFunction &Function = It.second;
     if (shouldOptimize(Function))
       runOnFunction(Function);
   }
 
+  if (DeletedBlocks)
     outs() << "BOLT-INFO: UCE removed " << DeletedBlocks << " blocks and "
-         << DeletedBytes << " bytes of code.\n";
+           << DeletedBytes << " bytes of code\n";
 }
 
 bool ReorderBasicBlocks::shouldPrint(const BinaryFunction &BF) const {
   return (BinaryFunctionPass::shouldPrint(BF) &&
           opts::ReorderBlocks != ReorderBasicBlocks::LT_NONE);
 }
 
 bool ReorderBasicBlocks::shouldOptimize(const BinaryFunction &BF) const {
if (!shouldOptimize(Function))
       continue;
 
     if (fixTailCalls(Function)) {
       Modified.insert(&Function);
       Function.setHasCanonicalCFG(false);
     }
   }
 
+  if (NumTailCallsPatched)
     outs() << "BOLT-INFO: SCTC: patched " << NumTailCallsPatched
            << " tail calls (" << NumOrigForwardBranches << " forward)"
            << " tail calls (" << NumOrigBackwardBranches << " backward)"
            << " from a total of " << NumCandidateTailCalls << " while removing "
            << NumDoubleJumps << " double jumps"
            << " and removing " << DeletedBlocks << " basic blocks"
            << " totalling " << DeletedBytes
            << " bytes of code. CTCs total execution count is " << CTCExecCount
            << " and the number of times CTCs are taken is " << CTCTakenCount
-         << ".\n";
+           << "\n";
 }
 
 uint64_t ShortenInstructions::shortenInstructions(BinaryFunction &Function) {
   uint64_t Count = 0;
   const BinaryContext &BC = Function.getBinaryContext();
   for (BinaryBasicBlock &BB : Function) {
     for (MCInst &Inst : BB) {
       MCInst OriginalInst;
void ShortenInstructions::runOnFunctions(BinaryContext &BC) {
   if (!BC.isX86())
     return;
 
   ParallelUtilities::runOnEachFunction(
       BC, ParallelUtilities::SchedulingPolicy::SP_INST_LINEAR,
       [&](BinaryFunction &BF) { NumShortened += shortenInstructions(BF); },
       nullptr, "ShortenInstructions");
 
+  if (NumShortened)
     outs() << "BOLT-INFO: " << NumShortened << " instructions were shortened\n";
 }
 
 void Peepholes::addTailcallTraps(BinaryFunction &Function) {
   MCPlusBuilder *MIB = Function.getBinaryContext().MIB.get();
   for (BinaryBasicBlock &BB : Function) {
     MCInst *Inst = BB.getLastNonPseudoInstr();
     if (Inst && MIB->isTailCall(*Inst) && MIB->isIndirectBranch(*Inst)) {
       MCInst Trap;

bolt/test/X86/issue20.s

 # This reproduces issue 20 from our github repo
 #  "BOLT crashes when removing unreachable BBs that are a target
 #   in a JT"
 
 # REQUIRES: system-linux
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
 # RUN:   %s -o %t.o
 # RUN: %clang %cflags -no-pie %t.o -o %t.exe
 # RUN: llvm-bolt %t.exe --relocs=0 --jump-tables=move --print-finalized \
 # RUN:    -o %t.out | FileCheck %s
 
-# CHECK: BOLT-INFO: UCE removed 0 blocks and 0 bytes of code.
+# CHECK-NOT: BOLT-INFO: UCE removed {{.*}} blocks and {{.*}} bytes of code
 # CHECK: Binary Function "main"
 # CHECK:      .LFT{{.*}} (2 instructions, align : 1)
 # CHECK-NEXT:   CFI State : 0
 # CHECK-NEXT:     00000004:   andq
 # CHECK-NEXT:     00000008:   jmpq
 # CHECK-NEXT:   Successors: .Ltmp{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}
 
 

bolt/test/X86/issue20.test

 # This reproduces issue 20 from our github repo
 #  "BOLT crashes when removing unreachable BBs that are a target
 #   in a JT"
 
 # RUN: yaml2obj %p/Inputs/issue20.yaml &> %t.exe
 # RUN: llvm-bolt %t.exe --relocs=0 --jump-tables=move --print-finalized \
 # RUN:    -o %t.out | FileCheck %s
 
-CHECK: BOLT-INFO: UCE removed 0 blocks and 0 bytes of code.
+CHECK-NOT: BOLT-INFO: UCE removed {{.*}} blocks and {{.*}}| bytes of code
 CHECK: Binary Function "main"
 CHECK:      .LFT0 (2 instructions, align : 1)
 CHECK-NEXT:   CFI State : 0
 CHECK-NEXT:     00000004:   andq
 CHECK-NEXT:     00000008:   jmpq
 CHECK-NEXT:   Successors: .Ltmp1, .Ltmp2, .Ltmp3, .Ltmp4

bolt/test/X86/unreachable.test

 # Check unreachable code elimination
 
 RUN: %clang %cflags %p/../Inputs/stub.c -fPIC -pie -shared -o %t.so
 RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
 RUN:   %p/Inputs/unreachable.s -o %t.o
 RUN: %clangxx %cxxflags -no-pie %t.o -o %t.exe %t.so
 RUN: llvm-bolt %t.exe -o %t \
 RUN:   -reorder-blocks=none -split-functions -eliminate-unreachable \
 RUN:   -funcs=foo -use-gnu-stack -print-cfg -print-finalized \
 RUN:   | FileCheck %s --check-prefix=BOLT
 RUN: llvm-objdump -d %t --print-imm-hex --disassemble-symbols=foo \
 RUN:   --no-show-raw-insn | FileCheck %s
 
 BOLT: BB Layout   : .LBB{{.*}}, .LFT{{.*}}, .Ltmp{{.*}}, .LFT{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}, .LLP{{.*}}, .LFT{{.*}}, .Ltmp{{.*}}, .LFT{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}
-BOLT: BOLT-INFO: UCE removed 4 blocks and 16 bytes of code.
+BOLT: BOLT-INFO: UCE removed 4 blocks and 16 bytes of code
 BOLT: BB Layout   : .LBB{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}, .LLP{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}
 
 CHECK: <foo>:
 CHECK-NEXT: pushq   %rbp
 CHECK-NEXT: movq    %rsp, %rbp
 CHECK-NEXT: pushq   %rbx
 CHECK-NEXT: subq    $0x18, %rsp
 CHECK-NEXT: movq    %rdi, -0x18(%rbp)