add a cl::opt override for TargetLowering's JumpIsExpensive

[spatel]

Summary

This patch is not intended to change existing codegen behavior for any target. It just exposes the JumpIsExpensive setting on the command-line to allow for easier testing and emergency overrides.

Also, change the existing regression test to use FileCheck, explicitly specify the jump-is-expensive option, and use more precise checks.

[kbsmith1]

Seems like for the unit test that it would be better to not be quite so specific. For the JUMPY case, maybe
CHECK-DAG: jl
CHECK-DAG: je
would be better, and a little less fragile because it seems like the ordering of the jumps could be arbitrary.
For the NOJMP case, maybe just check for one set, the or, and then a je or jne?

[spatel]

Thanks, Kevin.
Updated test case to be more flexible.

[kbsmith1]

LGTM on unit test.

[spatel]

Sorry - is that 'LGTM' for the whole patch or just on the test case?

[kbsmith1]

I reviewed both the code and the test. Both are LGTM to me at this point. I simply don't know whether Hal or Chandler would consider me as a qualified code reviewer at this point.

[spatel]

Thanks, Kevin. I made the judgement call that you are, in fact, a qualified reviewer. :)
Committed at r241179.

llvm/trunk/include/llvm/Target/TargetLowering.h

protected:
   /// Tells the code generator that the target has BitExtract instructions.
   /// The code generator will aggressively sink "shift"s into the blocks of
   /// their users if the users will generate "and" instructions which can be
   /// combined with "shift" to BitExtract instructions.
   void setHasExtractBitsInsn(bool hasExtractInsn = true) {
     HasExtractBitsInsn = hasExtractInsn;
   }
 
-  /// Tells the code generator not to expand sequence of operations into a
-  /// separate sequences that increases the amount of flow control.
-  void setJumpIsExpensive(bool isExpensive = true) {
-    JumpIsExpensive = isExpensive;
-  }
+  /// Tells the code generator not to expand logic operations on comparison
+  /// predicates into separate sequences that increase the amount of flow
+  /// control.
+  void setJumpIsExpensive(bool isExpensive = true);
 
   /// Tells the code generator that integer divide is expensive, and if
   /// possible, should be replaced by an alternate sequence of instructions not
   /// containing an integer divide.
   void setIntDivIsCheap(bool isCheap = true) { IntDivIsCheap = isCheap; }
 
   /// Tells the code generator that fsqrt is cheap, and should not be replaced
   /// with an alternative sequence of instructions.

llvm/trunk/lib/CodeGen/TargetLoweringBase.cpp

 #include "llvm/Support/MathExtras.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 #include <cctype>
 using namespace llvm;
 
+static cl::opt<bool> JumpIsExpensiveOverride(
+    "jump-is-expensive", cl::init(false),
+    cl::desc("Do not create extra branches to split comparison logic."),
+    cl::Hidden);
+
 /// InitLibcallNames - Set default libcall names.
 ///
 static void InitLibcallNames(const char **Names, const Triple &TT) {
   Names[RTLIB::SHL_I16] = "__ashlhi3";
   Names[RTLIB::SHL_I32] = "__ashlsi3";
   Names[RTLIB::SHL_I64] = "__ashldi3";
   Names[RTLIB::SHL_I128] = "__ashlti3";
   Names[RTLIB::SRL_I16] = "__lshrhi3";
TargetLoweringBase::TargetLoweringBase(const TargetMachine &tm) : TM(tm) {
   UseUnderscoreSetJmp = false;
   UseUnderscoreLongJmp = false;
   SelectIsExpensive = false;
   HasMultipleConditionRegisters = false;
   HasExtractBitsInsn = false;
   IntDivIsCheap = false;
   FsqrtIsCheap = false;
   Pow2SDivIsCheap = false;
-  JumpIsExpensive = false;
+  JumpIsExpensive = JumpIsExpensiveOverride;
   PredictableSelectIsExpensive = false;
   MaskAndBranchFoldingIsLegal = false;
   EnableExtLdPromotion = false;
   HasFloatingPointExceptions = true;
   StackPointerRegisterToSaveRestore = 0;
   ExceptionPointerRegister = 0;
   ExceptionSelectorRegister = 0;
   BooleanContents = UndefinedBooleanContent;
bool TargetLoweringBase::canOpTrap(unsigned Op, EVT VT) const {
   case ISD::SDIV:
   case ISD::UDIV:
   case ISD::SREM:
   case ISD::UREM:
     return true;
   }
 }
 
+void TargetLoweringBase::setJumpIsExpensive(bool isExpensive) {
+  // If the command-line option was specified, ignore this request.
+  if (!JumpIsExpensiveOverride.getNumOccurrences())
+    JumpIsExpensive = isExpensive;
+}
+
 TargetLoweringBase::LegalizeKind
 TargetLoweringBase::getTypeConversion(LLVMContext &Context, EVT VT) const {
   // If this is a simple type, use the ComputeRegisterProp mechanism.
   if (VT.isSimple()) {
     MVT SVT = VT.getSimpleVT();
     assert((unsigned)SVT.SimpleTy < array_lengthof(TransformToType));
     MVT NVT = TransformToType[SVT.SimpleTy];
     LegalizeTypeAction LA = ValueTypeActions.getTypeAction(SVT);

llvm/trunk/test/CodeGen/X86/or-branch.ll

-; RUN: llc < %s -march=x86  | not grep set
+; RUN: llc < %s -mtriple=i386-unknown-unknown -jump-is-expensive=0 | FileCheck %s --check-prefix=JUMP2
+; RUN: llc < %s -mtriple=i386-unknown-unknown -jump-is-expensive=1 | FileCheck %s --check-prefix=JUMP1
 
 define void @foo(i32 %X, i32 %Y, i32 %Z) nounwind {
+; JUMP2-LABEL: foo:
+; JUMP2-DAG:     jl
+; JUMP2-DAG:     je
+;
+; JUMP1-LABEL: foo:
+; JUMP1-DAG:     sete
+; JUMP1-DAG:     setl
+; JUMP1:         orb
+; JUMP1:         jne
 entry:
-  %tmp = tail call i32 (...) @bar( )    ; <i32> [#uses=0]
-  %tmp.upgrd.1 = icmp eq i32 %X, 0    ; <i1> [#uses=1]
-  %tmp3 = icmp slt i32 %Y, 5    ; <i1> [#uses=1]
-  %tmp4 = or i1 %tmp3, %tmp.upgrd.1   ; <i1> [#uses=1]
-  br i1 %tmp4, label %cond_true, label %UnifiedReturnBlock
+  %tmp1 = icmp eq i32 %X, 0
+  %tmp3 = icmp slt i32 %Y, 5
+  %tmp4 = or i1 %tmp3, %tmp1
+  br i1 %tmp4, label %cond_true, label %UnifiedReturnBlock
 
-cond_true:    ; preds = %entry
-  %tmp5 = tail call i32 (...) @bar( )    ; <i32> [#uses=0]
-  ret void
+cond_true:
+  %tmp5 = tail call i32 (...) @bar( )
+  ret void
 
-UnifiedReturnBlock:   ; preds = %entry
-  ret void
+UnifiedReturnBlock:
+  ret void
 }
 
 declare i32 @bar(...)