Switch the constant expression speculation cost evaluation away from

a cost fuction that seems both a bit ad-hoc and also poorly suited to
evaluating constant expressions.

Notably, it is missing any support for trivial expressions such as
'inttoptr'. I could fix this routine, but it isn't clear to me all of
the constraints its other users are operating under.

The core protection that seems relevant here is avoiding the formation
of a select instruction wich a further chain of select operations in
a constant expression operand. Just explicitly encode that constraint.

Also, update the comments and organization here to make it clear where
this needs to go -- this should be driven off of real cost measurements
which take into account the number of constants expressions and the
depth of the constant expression tree.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@173340 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Transforms/Utils/SimplifyCFG.cpp b/lib/Transforms/Utils/SimplifyCFG.cpp
index 0e382874dcfe7076ebd9c7013389cacd8c628ffe..7ec31657ec44a8e706b811e5b6d9ba0b292b2565 100644 (file)
--- a/lib/Transforms/Utils/SimplifyCFG.cpp
+++ b/lib/Transforms/Utils/SimplifyCFG.cpp
@@ -1433,21 +1433,28 @@ static bool SpeculativelyExecuteBB(BranchInst *BI, BasicBlock *ThenBB) {
       continue;
 
     HaveRewritablePHIs = true;
-
-    // Check for safety.
     ConstantExpr *CE = dyn_cast<ConstantExpr>(ThenV);
     if (!CE)
-      continue; // Known safe.
+      continue; // Known safe and cheap.
+
+    if (!isSafeToSpeculativelyExecute(CE))
+      return false;
+
+    // Don't speculate into a select with a constant select expression operand.
+    // FIXME: This should really be a cost metric, but our cost model doesn't
+    // accurately model the expense of select.
+    if (Operator::getOpcode(CE) == Instruction::Select)
+      return false;
 
     // An unfolded ConstantExpr could end up getting expanded into
     // Instructions. Don't speculate this and another instruction at
     // the same time.
+    // FIXME: This is strange because provided we haven't already hit the cost
+    // of 1, this code will speculate an arbitrary number of complex constant
+    // expression PHI nodes. Also, this doesn't account for how complex the
+    // constant expression is.
     if (SpeculationCost > 0)
       return false;
-    if (!isSafeToSpeculativelyExecute(CE))
-      return false;
-    if (ComputeSpeculationCost(CE) > PHINodeFoldingThreshold)
-      return false;
   }
 
   // If there are no PHIs to process, bail early. This helps ensure idempotence

diff --git a/test/Transforms/SimplifyCFG/SpeculativeExec.ll b/test/Transforms/SimplifyCFG/SpeculativeExec.ll
index a61867fe89c70873d074b36cf50d0a8cef883d76..c66d3ec67becca469e95832d6fed3fe1aae149e8 100644 (file)
--- a/test/Transforms/SimplifyCFG/SpeculativeExec.ll
+++ b/test/Transforms/SimplifyCFG/SpeculativeExec.ll
@@ -44,3 +44,25 @@ join:
   ret i8 %c
 }
 
+define i8* @test3(i1* %dummy, i8* %a, i8* %b) {
+; Test that a weird, unfolded constant cast in the PHI don't block speculation.
+; CHECK: @test3
+
+entry:
+  %cond1 = load volatile i1* %dummy
+  br i1 %cond1, label %if, label %end
+
+if:
+  %cond2 = load volatile i1* %dummy
+  br i1 %cond2, label %then, label %end
+
+then:
+  br label %end
+
+end:
+  %x = phi i8* [ %a, %entry ], [ %b, %if ], [ inttoptr (i64 42 to i8*), %then ]
+; CHECK-NOT: phi
+; CHECK: select i1 %cond2, i8* inttoptr
+
+  ret i8* %x
+}