[SCCP] Drop unnecessary early exit for ExtractValueInst.

[fhahn]

Summary

visitExtractValueInst uses mergeInValue, so it already can handle
constant ranges. Initially the early exit was using isOverdefined to
keep things as NFC during the initial move to ValueLatticeElement.
As the function already supports constant ranges, it can just use
ValueState[&I].isOverdefined.

[efriedma]

LGTM

[fhahn]

rebased

llvm/lib/Transforms/Scalar/SCCP.cpp

 //===- SCCP.cpp - Sparse Conditional Constant Propagation -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (Constant *OpC = getConstant(OpSt)) {
     ConstantRange Res =
         OpRange.castOp(I.getOpcode(), DL.getTypeSizeInBits(DestTy));
     mergeInValue(LV, &I, ValueLatticeElement::getRange(Res));
   } else if (!OpSt.isUnknownOrUndef())
     markOverdefined(&I);
 }
 
 void SCCPSolver::visitExtractValueInst(ExtractValueInst &EVI) {
-  // ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would
-  // discover a concrete value later.
-  if (isOverdefined(ValueState[&EVI]))
-    return (void)markOverdefined(&EVI);
-
   // If this returns a struct, mark all elements over defined, we don't track
   // structs in structs.
   if (EVI.getType()->isStructTy())
     return (void)markOverdefined(&EVI);
 
+  // ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would
+  // discover a concrete value later.
+  if (ValueState[&EVI].isOverdefined())
+    return (void)markOverdefined(&EVI);
+
   // If this is extracting from more than one level of struct, we don't know.
   if (EVI.getNumIndices() != 1)
     return (void)markOverdefined(&EVI);
 
   Value *AggVal = EVI.getAggregateOperand();
   if (AggVal->getType()->isStructTy()) {
     unsigned i = *EVI.idx_begin();
     ValueLatticeElement EltVal = getStructValueState(AggVal, i);

llvm/test/Transforms/SCCP/conditions-ranges.ll

 ; CHECK-NEXT:    br i1 [[BC_2]], label [[TRUE:%.*]], label [[FALSE:%.*]]
 ; CHECK:       true:
 ; CHECK-NEXT:    [[F_1:%.*]] = icmp eq i32 [[A]], 0
 ; CHECK-NEXT:    call void @use(i1 [[F_1]])
 ; CHECK-NEXT:    [[F_2:%.*]] = icmp eq i32 [[A]], 20
 ; CHECK-NEXT:    call void @use(i1 [[F_2]])
 ; CHECK-NEXT:    [[F_3:%.*]] = icmp ugt i32 [[A]], 100
 ; CHECK-NEXT:    call void @use(i1 [[F_3]])
+; CHECK-NEXT:    [[F_4:%.*]] = icmp eq i32 [[B]], 0
+; CHECK-NEXT:    call void @use(i1 [[F_3]])
+; CHECK-NEXT:    [[F_5:%.*]] = icmp eq i32 [[B]], 20
+; CHECK-NEXT:    call void @use(i1 [[F_5]])
+; CHECK-NEXT:    [[F_6:%.*]] = icmp ugt i32 [[B]], 100
+; CHECK-NEXT:    call void @use(i1 [[F_6]])
 ; CHECK-NEXT:    [[T_1:%.*]] = icmp ult i32 [[A]], 100
 ; CHECK-NEXT:    call void @use(i1 [[T_1]])
 ; CHECK-NEXT:    [[T_2:%.*]] = icmp ne i32 [[A]], 20
 ; CHECK-NEXT:    call void @use(i1 [[T_2]])
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp eq i32 [[A]], 21
 ; CHECK-NEXT:    call void @use(i1 [[C_1]])
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ugt i32 [[A]], 21
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp ugt i32 [[A]], 50
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       false:
-; CHECK-NEXT:    [[F_4:%.*]] = icmp eq i32 [[A]], 50
-; CHECK-NEXT:    call void @use(i1 [[F_4]])
+; CHECK-NEXT:    [[F_7:%.*]] = icmp eq i32 [[A]], 50
+; CHECK-NEXT:    call void @use(i1 [[F_7]])
 ; CHECK-NEXT:    [[T_3:%.*]] = icmp ne i32 [[A]], 50
 ; CHECK-NEXT:    call void @use(i1 [[T_3]])
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp eq i32 [[A]], 10
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
 ; CHECK-NEXT:    [[C_5:%.*]] = icmp eq i32 [[B]], 100
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %lt = icmp ult i32 %a, 100
   %gt = icmp ugt i32 %a, 20
   %bc = and i1 %lt, %gt
   %b.lt = icmp ult i32 %b, 50
   %bc.2 = and i1 %bc, %b.lt
   br i1 %bc.2, label %true, label %false
 
 true: ; %a in [21, 100)
   ; Conditions below are false.
   %f.1 = icmp eq i32 %a, 0
   call void @use(i1 %f.1)
   %f.2 = icmp eq i32 %a, 20
   call void @use(i1 %f.2)
   %f.3 = icmp ugt i32 %a, 100
   call void @use(i1 %f.3)
+  %f.4 = icmp eq i32 %b, 0
+  call void @use(i1 %f.3)
+  %f.5 = icmp eq i32 %b, 20
+  call void @use(i1 %f.5)
+  %f.6 = icmp ugt i32 %b, 100
+  call void @use(i1 %f.6)
+
 
   ; Conditions below are true.
   %t.1 = icmp ult i32 %a, 100
   call void @use(i1 %t.1)
   %t.2 = icmp ne i32 %a, 20
   call void @use(i1 %t.2)
 
   ; Conditions below cannot be simplified.
   %c.1 = icmp eq i32 %a, 21
   call void @use(i1 %c.1)
   %c.2 = icmp ugt i32 %a, 21
   call void @use(i1 %c.2)
   %c.3 = icmp ugt i32 %a, 50
   call void @use(i1 %c.3)
   ret void
 
 false:
   ; Conditions below are false;
-  %f.4 = icmp eq i32 %a, 50
-  call void @use(i1 %f.4)
+  %f.7 = icmp eq i32 %a, 50
+  call void @use(i1 %f.7)
 
   ; Conditions below are true;
   %t.3 = icmp ne i32 %a, 50
   call void @use(i1 %t.3)
 
   ; Conditions below cannot be simplified.
   %c.4 = icmp eq i32 %a, 10
   call void @use(i1 %c.4)

llvm/test/Transforms/SCCP/constant-range-struct.ll

 
 define void @struct2_caller() {
 ; CHECK-LABEL: @struct2_caller(
 ; CHECK-NEXT:    [[S:%.*]] = call { i64, i64 } @struct2()
 ; CHECK-NEXT:    [[V1:%.*]] = extractvalue { i64, i64 } [[S]], 0
 ; CHECK-NEXT:    [[V2:%.*]] = extractvalue { i64, i64 } [[S]], 1
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    call void @use(i1 true)
-; CHECK-NEXT:    [[T_3:%.*]] = icmp ne i64 [[V2]], 0
-; CHECK-NEXT:    call void @use(i1 [[T_3]])
-; CHECK-NEXT:    [[T_4:%.*]] = icmp ult i64 [[V2]], 301
-; CHECK-NEXT:    call void @use(i1 [[T_4]])
+; CHECK-NEXT:    call void @use(i1 true)
+; CHECK-NEXT:    call void @use(i1 true)
+; CHECK-NEXT:    call void @use(i1 false)
+; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    call void @use(i1 false)
-; CHECK-NEXT:    [[F_3:%.*]] = icmp eq i64 [[V2]], 50
-; CHECK-NEXT:    call void @use(i1 [[F_3]])
-; CHECK-NEXT:    [[F_4:%.*]] = icmp ugt i64 [[V2]], 301
-; CHECK-NEXT:    call void @use(i1 [[F_4]])
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp eq i64 [[V1]], 25
 ; CHECK-NEXT:    call void @use(i1 [[C_1]])
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp ult i64 [[V1]], 25
 ; CHECK-NEXT:    call void @use(i1 [[C_2]])
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp eq i64 [[V2]], 250
 ; CHECK-NEXT:    call void @use(i1 [[C_3]])
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp ugt i64 [[V2]], 250
 ; CHECK-NEXT:    call void @use(i1 [[C_4]])
;
   call void @use(i1 %c.1)
   %c.2 = icmp ult i64 %v1, 25
   call void @use(i1 %c.2)
   %c.3 = icmp eq i64 %v2, 250
   call void @use(i1 %c.3)
   %c.4 = icmp ugt i64 %v2, 250
   call void @use(i1 %c.4)
 
-
   ret void
 }