[MIRPrinter] Print raw branch probabilities as expected by MIRParser

[MatzeB]

Thanks, this will fix http://llvm.org/PR28751

LGTM with the points below addressed:

include/llvm/Support/BranchProbability.h

73

I would lean towards just adding a getRaw() const function and leaving the printing to the MIRPrinter in the grounds that there is no matching parseRaw() function here as well.

The fact that the current code broke, is because the MIRPrinter was implemented with print() whose format changed in time, while the parse in MIParser stayed the same.

lib/CodeGen/MIRPrinter.cpp

485

I'd lean towards printing it in hex.

include/llvm/Support/BranchProbability.h

public:
 
   uint32_t getNumerator() const { return N; }
   static uint32_t getDenominator() { return D; }
 
   // Return (1 - Probability).
   BranchProbability getCompl() const { return BranchProbability(D - N); }
 
   raw_ostream &print(raw_ostream &OS) const;
+  raw_ostream &printRaw(raw_ostream &OS) const;
 
   void dump() const;
 
   /// \brief Scale a large integer.
   ///
   /// Scales \c Num.  Guarantees full precision.  Returns the floor of the
   /// result.
   ///

lib/CodeGen/MIRPrinter.cpp

void MIPrinter::print(const MachineBasicBlock &MBB) {
   bool HasLineAttributes = false;
   // Print the successors
   if (!MBB.succ_empty()) {
     OS.indent(2) << "successors: ";
     for (auto I = MBB.succ_begin(), E = MBB.succ_end(); I != E; ++I) {
       if (I != MBB.succ_begin())
         OS << ", ";
       printMBBReference(**I);
-      if (MBB.hasSuccessorProbabilities())
-        OS << '(' << MBB.getSuccProbability(I) << ')';
+      if (MBB.hasSuccessorProbabilities()) {
+        OS << '(';
+        MBB.getSuccProbability(I).printRaw(OS);
+        OS << ')';
+      }
     }
     OS << "\n";
     HasLineAttributes = true;
   }
 
   // Print the live in registers.
   const auto *TRI = MBB.getParent()->getSubtarget().getRegisterInfo();
   assert(TRI && "Expected target register info");

lib/Support/BranchProbability.cpp

raw_ostream &BranchProbability::print(raw_ostream &OS) const {
   // implementation-defined rounding inside printf.
   double Percent = rint(((double)N / D) * 100.0 * 100.0) / 100.0;
   return OS << format("0x%08" PRIx32 " / 0x%08" PRIx32 " = %.2f%%", N, D,
                       Percent);
 }
 
 LLVM_DUMP_METHOD void BranchProbability::dump() const { print(dbgs()) << '\n'; }
 
+raw_ostream &BranchProbability::printRaw(raw_ostream &OS) const {
+  return OS << N;
+}
+
 BranchProbability::BranchProbability(uint32_t Numerator, uint32_t Denominator) {
   assert(Denominator > 0 && "Denominator cannot be 0!");
   assert(Numerator <= Denominator && "Probability cannot be bigger than 1!");
   if (Denominator == D)
     N = Numerator;
   else {
     uint64_t Prob64 =
         (Numerator * static_cast<uint64_t>(D) + Denominator / 2) / Denominator;

test/CodeGen/MIR/Generic/branch-probabilities.ll

+; RUN: llc -stop-after machine-sink %s -o %t.mir
+; RUN: FileCheck %s < %t.mir
+; RUN: llc %t.mir -run-pass machine-sink
+; Check that branch probabilities are printed in a format that can then be parsed.
+
+declare void @foo()
+declare void @bar()
+
+define void @test(i1 %c) {
+; CHECK-LABEL: name: test
+entry:
+        br i1 %c, label %then, label %else
+
+then:
+        call void @foo()
+        br label %end
+; CHECK: successors: %{{[a-z0-9\-\.]+}}({{[0-9]+}}), %{{[a-z0-9\-\.]+}}({{[0-9]+}})
+
+else:
+        call void @bar()
+        br label %end
+; CHECK: successors: %{{[a-z0-9\-\.]+}}({{[0-9]+}})
+
+end:
+        ret void
+}

test/CodeGen/MIR/X86/newline-handling.mir

 ---
 name:            foo
 tracksRegLiveness: true
 liveins:
   - { reg: '%edi' }
 # CHECK-LABEL: name: foo
 # CHECK: body: |
 # CHECK-NEXT: bb.0.entry:
-# CHECK-NEXT: successors: %bb.1.less(0x40000000 / 0x80000000 = 50.00%), %bb.2.exit(0x40000000 / 0x80000000 = 50.00%)
+# CHECK-NEXT: successors: %bb.1.less(1073741824), %bb.2.exit(1073741824)
 # CHECK-NEXT: liveins: %edi
 # CHECK:      CMP32ri8 %edi, 10, implicit-def %eflags
 # CHECK-NEXT: JG_1 %bb.2.exit, implicit killed %eflags
 
 # CHECK:      bb.1.less:
 # CHECK-NEXT: %eax = MOV32r0 implicit-def dead %eflags
 # CHECK-NEXT: RETQ killed %eax
 

 ---
 name:            bar
 tracksRegLiveness: true
 liveins:
   - { reg: '%edi' }
 # CHECK-LABEL: name: bar
 # CHECK: body: |
 # CHECK-NEXT: bb.0.entry:
-# CHECK-NEXT: successors: %bb.1.less(0x40000000 / 0x80000000 = 50.00%), %bb.2.exit(0x40000000 / 0x80000000 = 50.00%)
+# CHECK-NEXT: successors: %bb.1.less(1073741824), %bb.2.exit(1073741824)
 # CHECK-NEXT: liveins: %edi
 # CHECK:      CMP32ri8 %edi, 10, implicit-def %eflags
 # CHECK-NEXT: JG_1 %bb.2.exit, implicit killed %eflags
 
 # CHECK:      bb.1.less:
 # CHECK-NEXT: %eax = MOV32r0 implicit-def dead %eflags
 # CHECK-NEXT: RETQ killed %eax
 

test/CodeGen/MIR/X86/successor-basic-blocks-weights.mir

exit:
     ret i32 %a
   }
 
 ...
 ---
 name:            foo
 body: |
   ; CHECK-LABEL: bb.0.entry:
-  ; CHECK:         successors: %bb.1.less({{[0-9a-fx/= ]+}}33.00%), %bb.2.exit({{[0-9a-fx/= ]+}}67.00%)
+  ; CHECK:         successors: %bb.1.less(708669604), %bb.2.exit(1438814044)
   ; CHECK-LABEL: bb.1.less:
   bb.0.entry:
     successors: %bb.1.less (33), %bb.2.exit(67)
     liveins: %edi
 
     CMP32ri8 %edi, 10, implicit-def %eflags
     JG_1 %bb.2.exit, implicit killed %eflags
 

test/CodeGen/MIR/X86/successor-basic-blocks.mir

; <label>:1
     ret i32 %a
   }
 
 ...
 ---
 name:            foo
 body: |
   ; CHECK-LABEL: bb.0.entry:
-  ; CHECK:         successors: %bb.1.less(0x40000000 / 0x80000000 = 50.00%), %bb.2.exit(0x40000000 / 0x80000000 = 50.00%)
+  ; CHECK:         successors: %bb.1.less(1073741824), %bb.2.exit(1073741824)
   ; CHECK-LABEL: bb.1.less:
   bb.0.entry:
     successors: %bb.1.less, %bb.2.exit
     liveins: %edi
 
     CMP32ri8 %edi, 10, implicit-def %eflags
     JG_1 %bb.2.exit, implicit killed %eflags
 

 ...
 ---
 name:            bar
 body: |
   ; CHECK-LABEL: name: bar
   ; Verify that we can have multiple lists of successors that will be merged
   ; into one.
   ; CHECK-LABEL: bb.0.entry:
-  ; CHECK:         successors: %bb.1(0x80000000 / 0x80000000 = 100.00%), %bb.2(0x00000000 / 0x80000000 = 0.00%)
+  ; CHECK:         successors: %bb.1(2147483648), %bb.2(0)
   bb.0.entry:
     liveins: %edi
     successors: %bb.1
     successors: %bb.2
 
     CMP32ri8 %edi, 10, implicit-def %eflags
     JG_1 %bb.2, implicit killed %eflags