[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 ↗

(On Diff #78287)

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 ↗

(On Diff #78287)

I'd lean towards printing it in hex.

llvm/trunk/lib/CodeGen/MIRParser/MIParser.cpp

do {
     if (Token.isNot(MIToken::MachineBasicBlock))
       return error("expected a machine basic block reference");
     MachineBasicBlock *SuccMBB = nullptr;
     if (parseMBBReference(SuccMBB))
       return true;
     lex();
     unsigned Weight = 0;
     if (consumeIfPresent(MIToken::lparen)) {
-      if (Token.isNot(MIToken::IntegerLiteral))
+      if (Token.isNot(MIToken::IntegerLiteral) &&
+          Token.isNot(MIToken::HexLiteral))
         return error("expected an integer literal after '('");
       if (getUnsigned(Weight))
         return true;
       lex();
       if (expectAndConsume(MIToken::rparen))
         return true;
     }
     MBB.addSuccessor(SuccMBB, BranchProbability::getRaw(Weight));

llvm/trunk/lib/CodeGen/MIRPrinter.cpp

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/ModuleSlotTracker.h"
 #include "llvm/MC/MCSymbol.h"
+#include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetIntrinsicInfo.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 
 using namespace llvm;
void MIPrinter::print(const MachineBasicBlock &MBB) {
   // 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) << ')';
+        OS << '('
+           << format("0x%08" PRIx32, MBB.getSuccProbability(I).getNumerator())
+           << ')';
     }
     OS << "\n";
     HasLineAttributes = true;
   }
 
   // Print the live in registers.
   const auto *TRI = MBB.getParent()->getSubtarget().getRegisterInfo();
   assert(TRI && "Expected target register info");

llvm/trunk/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\-\.]+}}({{0x[0-9a-f]+}}), %{{[a-z0-9\-\.]+}}({{0x[0-9a-f]+}})
+
+else:
+        call void @bar()
+        br label %end
+; CHECK: successors: %{{[a-z0-9\-\.]+}}({{0x[0-9a-f]+}})
+
+end:
+        ret void
+}

llvm/trunk/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(0x40000000), %bb.2.exit(0x40000000)
 # 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(0x40000000), %bb.2.exit(0x40000000)
 # 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
 

llvm/trunk/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(0x2a3d70a4), %bb.2.exit(0x55c28f5c)
   ; 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
 

llvm/trunk/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(0x40000000), %bb.2.exit(0x40000000)
   ; 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(0x80000000), %bb.2(0x00000000)
   bb.0.entry:
     liveins: %edi
     successors: %bb.1
     successors: %bb.2
 
     CMP32ri8 %edi, 10, implicit-def %eflags
     JG_1 %bb.2, implicit killed %eflags