From 8726dc54e63349735411226b622d8b2eafea3f84 Mon Sep 17 00:00:00 2001
From: Quentin Colombet <qcolombet@apple.com>
Date: Tue, 19 Sep 2017 23:34:12 +0000
Subject: [PATCH] [MIRPrinter] Print empty successor lists when they cannot be
 guessed

This re-applies commit r313685, this time with the proper updates to
the test cases.

Original commit message:
Unreachable blocks in the machine instr representation are these
weird empty blocks with no successors.
The MIR printer used to not print empty lists of successors. However,
the MIR parser now treats non-printed list of successors as "please
guess it for me". As a result, the parser tries to guess the list of
successors and given the block is empty, just assumes it falls through
the next block (if any).

For instance, the following test case used to fail the verifier.
The MIR printer would print

         entry
        /      \
   true (def)   false (no list of successors)
       |
 split.true (use)

The MIR parser would understand this:

         entry
        /      \
   true (def)   false
       |        /  <-- invalid edge
 split.true (use)

Because of the invalid edge, we get the "def does not
dominate all uses" error.

The fix consists in printing empty successor lists, so that the parser
knows what to do for unreachable blocks.

rdar://problem/34022159

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@313696 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/CodeGen/MIRPrinter.cpp                      | 10 ++++--
 test/CodeGen/MIR/ARM/ifcvt_canFallThroughTo.mir |  3 +-
 test/CodeGen/MIR/X86/unreachable_block.ll       | 48 +++++++++++++++++++++++++
 3 files changed, 58 insertions(+), 3 deletions(-)
 create mode 100644 test/CodeGen/MIR/X86/unreachable_block.ll

diff --git a/lib/CodeGen/MIRPrinter.cpp b/lib/CodeGen/MIRPrinter.cpp
index db9ccef8a36..7650d634680 100644
--- a/lib/CodeGen/MIRPrinter.cpp
+++ b/lib/CodeGen/MIRPrinter.cpp
@@ -598,8 +598,14 @@ void MIPrinter::print(const MachineBasicBlock &MBB) {
   bool HasLineAttributes = false;
   // Print the successors
   bool canPredictProbs = canPredictBranchProbabilities(MBB);
-  if (!MBB.succ_empty() && (!SimplifyMIR || !canPredictProbs ||
-                            !canPredictSuccessors(MBB))) {
+  // Even if the list of successors is empty, if we cannot guess it,
+  // we need to print it to tell the parser that the list is empty.
+  // This is needed, because MI model unreachable as empty blocks
+  // with an empty successor list. If the parser would see that
+  // without the successor list, it would guess the code would
+  // fallthrough.
+  if ((!MBB.succ_empty() && !SimplifyMIR) || !canPredictProbs ||
+      !canPredictSuccessors(MBB)) {
     OS.indent(2) << "successors: ";
     for (auto I = MBB.succ_begin(), E = MBB.succ_end(); I != E; ++I) {
       if (I != MBB.succ_begin())
diff --git a/test/CodeGen/MIR/ARM/ifcvt_canFallThroughTo.mir b/test/CodeGen/MIR/ARM/ifcvt_canFallThroughTo.mir
index 5a1583f7a9b..90d606a162d 100644
--- a/test/CodeGen/MIR/ARM/ifcvt_canFallThroughTo.mir
+++ b/test/CodeGen/MIR/ARM/ifcvt_canFallThroughTo.mir
@@ -52,8 +52,9 @@ body:             |
 #CHECK:     B %bb.3
 
 # Empty bb.2, originally containing "unreachable" and thus has no successors
+# and we cannot guess them: we should print an empty list of successors.
 #CHECK:   bb.2:
-#CHECK-NOT: successors
+#CHECK: successors:{{ *$}}
 
 #CHECK:   bb.3:
 #CHECK:     successors: %bb.1
diff --git a/test/CodeGen/MIR/X86/unreachable_block.ll b/test/CodeGen/MIR/X86/unreachable_block.ll
new file mode 100644
index 00000000000..4cea0392255
--- /dev/null
+++ b/test/CodeGen/MIR/X86/unreachable_block.ll
@@ -0,0 +1,48 @@
+; RUN: llc -mtriple x86_64-- -stop-before peephole-opt -o %t.mir %s
+; RUN: llc -mtriple x86_64-- -run-pass none %t.mir -verify-machineinstrs -o - | FileCheck %s
+
+; Unreachable blocks in the machine instr representation are these
+; weird empty blocks with no successors.
+; The MIR printer used to not print empty lists of successors. However,
+; the MIR parser now treats non-printed list of successors as "please
+; guess it for me". As a result, the parser tries to guess the list of
+; successors and given the block is empty, just assumes it falls through
+; the next block.
+;
+; The following test case used to fail the verifier because the false
+; path ended up falling through split.true and now, the definition of
+; %v does not dominate all its uses.
+; Indeed, we go from the following CFG:
+;          entry
+;         /      \
+;    true (def)   false
+;        |
+;  split.true (use)
+;
+; To this one:
+;          entry
+;         /      \
+;    true (def)   false
+;        |        /  <-- invalid edge
+;  split.true (use)
+;
+; Because of the invalid edge, we get the "def does not
+; dominate all uses" error.
+;
+; CHECK-LABEL: name: foo
+; CHECK-LABEL: bb.{{[0-9]+}}.false:
+; CHECK-NEXT: successors:
+; CHECK-NOT: %bb.{{[0-9]+}}.split.true
+; CHECK-LABEL: bb.{{[0-9]+}}.split.true:
+define void @foo(i32* %bar) {
+  br i1 undef, label %true, label %false
+true:
+  %v = load i32, i32* %bar
+  br label %split.true
+false:
+  unreachable
+split.true:
+  %vInc = add i32 %v, 1
+  store i32 %vInc, i32* %bar
+  ret void
+}
-- 
2.11.0