Remove apparently obsolete builtin functions (#20947)

carlos4242 · stephentyrone · commit b91446471276 · 2018-12-03T07:07:34.000-05:00
* Remove apparently obsolete builtin functions.

- Remove s_to_u_checked_conversion and u_to_s_checked_conversion functions from builtin AST parsing, SIL/IR generation and from SIL optimisations.

* Remove apparently obsolete builtin functions - unit tests.

- Remove unit tests for SIL transformations relating to s_to_u_checked_conversion and u_to_s_checked_conversion builtin functions.
diff --git a/include/swift/AST/Builtins.def b/include/swift/AST/Builtins.def
@@ -478,14 +478,6 @@ BUILTIN_MISC_OPERATION(SToSCheckedTrunc, "s_to_s_checked_trunc", "n", Special)
 BUILTIN_MISC_OPERATION(SToUCheckedTrunc, "s_to_u_checked_trunc", "n", Special)
 BUILTIN_MISC_OPERATION(UToUCheckedTrunc, "u_to_u_checked_trunc", "n", Special)
 
-/// Checked conversions for signed <-> unsigned integers of the same size.
-/// Returns a tuple containing the conversion result as well as
-/// the sign error / overflow bit.
-BUILTIN_MISC_OPERATION(SUCheckedConversion,
-                       "s_to_u_checked_conversion", "n", Special)
-BUILTIN_MISC_OPERATION(USCheckedConversion,
-                       "u_to_s_checked_conversion", "n", Special)
-
 /// IntToFPWithOverflow has type (Integer) -> Float
 BUILTIN_MISC_OPERATION(IntToFPWithOverflow, "itofp_with_overflow", "n", Special)
 
diff --git a/include/swift/SIL/PatternMatch.h b/include/swift/SIL/PatternMatch.h
@@ -715,13 +715,6 @@ using BuiltinApplyTy = typename Apply_match<BuiltinValueKind, Tys...>::Ty;
 // if any of the sub-matchers succeed.
 //
 
-/// Matcher for any of the builtin checked conversions.
-template <typename T0>
-inline typename OneOf_match<BuiltinApplyTy<T0>, BuiltinApplyTy<T0>>::Ty
-m_CheckedConversion(const T0 &Op0) {
-  return m_USCheckedConversion(Op0) || m_SUCheckedConversion(Op0);
-}
-
 /// Matcher for any of the builtin ExtOrBitCast instructions.
 template <typename T0>
 inline typename OneOf_match<BuiltinApplyTy<T0>, BuiltinApplyTy<T0>>::Ty
diff --git a/lib/AST/Builtins.cpp b/lib/AST/Builtins.cpp
@@ -1106,19 +1106,6 @@ static ValueDecl *getCheckedTruncOperation(ASTContext &Context, Identifier Id,
   return getBuiltinFunction(Id, { InTy }, ResultTy);
 }
 
-static ValueDecl *getCheckedConversionOperation(ASTContext &Context,
-                                                Identifier Id,
-                                                Type Ty) {
-  Type BuiltinTy = Ty->getAs<BuiltinIntegerType>();
-  if (!BuiltinTy)
-    return nullptr;
-
-  Type SignErrorBitTy = BuiltinIntegerType::get(1, Context);
-  TupleTypeElt ResultElts[] = { BuiltinTy, SignErrorBitTy };
-  Type ResultTy = TupleType::get(ResultElts, Context);
-  return getBuiltinFunction(Id, { BuiltinTy }, ResultTy);
-}
-
 static ValueDecl *getIntToFPWithOverflowOperation(ASTContext &Context,
                                                   Identifier Id, Type InputTy,
                                                   Type OutputTy) {
@@ -1853,11 +1840,6 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
     if (Types.size() != 2) return nullptr;
     return getCheckedTruncOperation(Context, Id, Types[0], Types[1], false);
 
-  case BuiltinValueKind::SUCheckedConversion:
-  case BuiltinValueKind::USCheckedConversion:
-    if (Types.size() != 1) return nullptr;
-    return getCheckedConversionOperation(Context, Id, Types[0]);
-
   case BuiltinValueKind::ClassifyBridgeObject:
     if (!Types.empty()) return nullptr;
     return getClassifyBridgeObject(Context, Id);
diff --git a/lib/IRGen/GenBuiltin.cpp b/lib/IRGen/GenBuiltin.cpp
@@ -758,22 +758,6 @@ if (Builtin.ID == BuiltinValueKind::id) { \
     return out.add(OverflowFlag);
   }
 
-  if (Builtin.ID == BuiltinValueKind::SUCheckedConversion ||
-      Builtin.ID == BuiltinValueKind::USCheckedConversion) {
-    auto Ty =
-      IGF.IGM.getStorageTypeForLowered(Builtin.Types[0]->getCanonicalType());
-
-    // Report a sign error if the input parameter is a negative number, when
-    // interpreted as signed.
-    llvm::Value *Arg = args.claimNext();
-    llvm::Value *Zero = llvm::ConstantInt::get(Ty, 0);
-    llvm::Value *OverflowFlag = IGF.Builder.CreateICmpSLT(Arg, Zero);
-
-    // Return the tuple: (the result (same as input), the overflow flag).
-    out.add(Arg);
-    return out.add(OverflowFlag);
-  }
-
   // We are currently emitting code for '_convertFromBuiltinIntegerLiteral',
   // which will call the builtin and pass it a non-compile-time-const parameter.
   if (Builtin.ID == BuiltinValueKind::IntToFPWithOverflow) {
diff --git a/lib/SIL/OperandOwnership.cpp b/lib/SIL/OperandOwnership.cpp
@@ -1122,7 +1122,6 @@ CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, SRem)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, SSubOver)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, SToSCheckedTrunc)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, SToUCheckedTrunc)
-CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, SUCheckedConversion)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, Shl)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, Sizeof)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, StaticReport)
@@ -1140,7 +1139,6 @@ CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, UDiv)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, UIToFP)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, UMulOver)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, URem)
-CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, USCheckedConversion)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, USubOver)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, UToSCheckedTrunc)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, MustBeLive, UToUCheckedTrunc)
diff --git a/lib/SIL/ValueOwnership.cpp b/lib/SIL/ValueOwnership.cpp
@@ -479,8 +479,6 @@ CONSTANT_OWNERSHIP_BUILTIN(Trivial, UToSCheckedTrunc)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, SToSCheckedTrunc)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, SToUCheckedTrunc)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, UToUCheckedTrunc)
-CONSTANT_OWNERSHIP_BUILTIN(Trivial, SUCheckedConversion)
-CONSTANT_OWNERSHIP_BUILTIN(Trivial, USCheckedConversion)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, IntToFPWithOverflow)
 
 // This is surprising, Builtin.unreachable returns a "Never" value which is
diff --git a/lib/SILOptimizer/Analysis/SimplifyInstruction.cpp b/lib/SILOptimizer/Analysis/SimplifyInstruction.cpp
@@ -492,18 +492,6 @@ static SILValue simplifyBuiltin(BuiltinInst *BI) {
         return Result;
     }
 
-    // trunc(tuple_extract(conversion(extOrBitCast(x))))) -> x
-    if (match(Op, m_TupleExtractInst(
-                   m_CheckedConversion(
-                     m_ExtOrBitCast(m_SILValue(Result))), 0))) {
-      // If the top bit of Result is known to be 0, then
-      // it is safe to replace the whole pattern by original bits of x
-      if (Result->getType() == BI->getType()) {
-        if (auto signBit = computeSignBit(Result))
-          if (!signBit.getValue())
-            return Result;
-      }
-    }
     return SILValue();
   }
 
@@ -639,23 +627,6 @@ SILValue InstSimplifier::simplifyOverflowBuiltin(BuiltinInst *BI) {
   switch (Builtin.ID) {
   default: break;
 
-  case BuiltinValueKind::SUCheckedConversion:
-  case BuiltinValueKind::USCheckedConversion: {
-    OperandValueArrayRef Args = BI->getArguments();
-    const SILValue &Op = Args[0];
-    if (auto signBit = computeSignBit(Op))
-      if (!signBit.getValue())
-        return Op;
-    SILValue Result;
-    // CheckedConversion(ExtOrBitCast(x)) -> x
-    if (match(BI, m_CheckedConversion(m_ExtOrBitCast(m_SILValue(Result)))))
-      if (Result->getType() == BI->getType().getTupleElementType(0)) {
-        assert (!computeSignBit(Result).getValue() && "Sign bit should be 0");
-        return Result;
-      }
-    }
-    break;
-
   case BuiltinValueKind::UToSCheckedTrunc:
   case BuiltinValueKind::UToUCheckedTrunc:
   case BuiltinValueKind::SToUCheckedTrunc:
diff --git a/lib/SILOptimizer/Analysis/ValueTracking.cpp b/lib/SILOptimizer/Analysis/ValueTracking.cpp
@@ -296,25 +296,6 @@ Optional<bool> swift::computeSignBit(SILValue V) {
         continue;
       }
 
-      // Source and target type sizes are the same.
-      // S->U conversion can only succeed if
-      // the sign bit of its operand is 0, i.e. it is >= 0.
-      // The sign bit of a result is 0 only if the sign
-      // bit of a source operand is 0.
-      case BuiltinValueKind::SUCheckedConversion:
-        Value = BI->getArguments()[0];
-        continue;
-
-      // Source and target type sizes are the same.
-      // U->S conversion can only succeed if
-      // the top bit of its operand is 0, i.e.
-      // it is representable as a signed integer >=0.
-      // The sign bit of a result is 0 only if the sign
-      // bit of a source operand is 0.
-      case BuiltinValueKind::USCheckedConversion:
-        Value = BI->getArguments()[0];
-        continue;
-
       // Sign bit of the operand is promoted.
       case BuiltinValueKind::SExt:
         Value = BI->getArguments()[0];
diff --git a/lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp b/lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp
@@ -122,8 +122,6 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::SToUCheckedTrunc:
     case BuiltinValueKind::SToSCheckedTrunc:
     case BuiltinValueKind::UToUCheckedTrunc:
-    case BuiltinValueKind::SUCheckedConversion:
-    case BuiltinValueKind::USCheckedConversion:
     case BuiltinValueKind::IntToFPWithOverflow:
     case BuiltinValueKind::ZeroInitializer:
     case BuiltinValueKind::Once:
diff --git a/lib/SILOptimizer/Utils/ConstExpr.cpp b/lib/SILOptimizer/Utils/ConstExpr.cpp
@@ -210,8 +210,6 @@ ConstExprFunctionState::computeConstantValueBuiltin(BuiltinInst *inst) {
     if (!operand.isConstant())
       return operand;
 
-    // TODO: SUCheckedConversion/USCheckedConversion
-
     // Implement support for s_to_s_checked_trunc_Int2048_Int64 and other
     // checking integer truncates.  These produce a tuple of the result value
     // and an overflow bit.
diff --git a/lib/SILOptimizer/Utils/ConstantFolding.cpp b/lib/SILOptimizer/Utils/ConstantFolding.cpp
@@ -674,9 +674,7 @@ constantFoldAndCheckIntegerConversions(BuiltinInst *BI,
   assert(Builtin.ID == BuiltinValueKind::SToSCheckedTrunc ||
          Builtin.ID == BuiltinValueKind::UToUCheckedTrunc ||
          Builtin.ID == BuiltinValueKind::SToUCheckedTrunc ||
-         Builtin.ID == BuiltinValueKind::UToSCheckedTrunc ||
-         Builtin.ID == BuiltinValueKind::SUCheckedConversion ||
-         Builtin.ID == BuiltinValueKind::USCheckedConversion);
+         Builtin.ID == BuiltinValueKind::UToSCheckedTrunc);
 
   // Check if we are converting a constant integer.
   OperandValueArrayRef Args = BI->getArguments();
@@ -688,11 +686,9 @@ constantFoldAndCheckIntegerConversions(BuiltinInst *BI,
   auto SrcBitWidth = SrcVal.getBitWidth();
 
   bool DstTySigned = (Builtin.ID == BuiltinValueKind::SToSCheckedTrunc ||
-                      Builtin.ID == BuiltinValueKind::UToSCheckedTrunc ||
-                      Builtin.ID == BuiltinValueKind::USCheckedConversion);
+                      Builtin.ID == BuiltinValueKind::UToSCheckedTrunc);
   bool SrcTySigned = (Builtin.ID == BuiltinValueKind::SToSCheckedTrunc ||
-                      Builtin.ID == BuiltinValueKind::SToUCheckedTrunc ||
-                      Builtin.ID == BuiltinValueKind::SUCheckedConversion);
+                      Builtin.ID == BuiltinValueKind::SToUCheckedTrunc);
 
   // Get source type and bit width.
   auto SrcTy = Builtin.Types[0]->castTo<AnyBuiltinIntegerType>();
@@ -705,44 +701,33 @@ constantFoldAndCheckIntegerConversions(BuiltinInst *BI,
   bool OverflowError;
   Type DstTy;
 
-  // Process conversions signed <-> unsigned for same size integers.
-  if (Builtin.ID == BuiltinValueKind::SUCheckedConversion ||
-      Builtin.ID == BuiltinValueKind::USCheckedConversion) {
-    DstTy = SrcTy;
+  assert(Builtin.Types.size() == 2);
+  DstTy = Builtin.Types[1];
+  uint32_t DstBitWidth =
+    DstTy->castTo<BuiltinIntegerType>()->getGreatestWidth();
+
+  assert((DstBitWidth < SrcBitWidth || !SrcTy->getWidth().isFixedWidth()) &&
+         "preconditions on builtin trunc operations should prevent"
+         "fixed-width truncations that actually extend");
+
+  // The only way a true extension can overflow is if the value is
+  // negative and the result is unsigned.
+  if (DstBitWidth > SrcBitWidth) {
+    OverflowError = (SrcTySigned && !DstTySigned && SrcVal.isNegative());
+    Result = (SrcTySigned ? SrcVal.sext(DstBitWidth)
+                          : SrcVal.zext(DstBitWidth));
+
+  // A same-width change can overflow if the top bit disagrees.
+  } else if (DstBitWidth == SrcBitWidth) {
+    OverflowError = (SrcTySigned != DstTySigned && SrcVal.isNegative());
     Result = SrcVal;
-    // Report an error if the sign bit is set.
-    OverflowError = SrcVal.isNegative();
 
-  // Process the checked truncations.
+  // A truncation can overflow if the value changes.
   } else {
-    assert(Builtin.Types.size() == 2);
-    DstTy = Builtin.Types[1];
-    uint32_t DstBitWidth =
-      DstTy->castTo<BuiltinIntegerType>()->getGreatestWidth();
-
-    assert((DstBitWidth < SrcBitWidth || !SrcTy->getWidth().isFixedWidth()) &&
-           "preconditions on builtin trunc operations should prevent"
-           "fixed-width truncations that actually extend");
-
-    // The only way a true extension can overflow is if the value is
-    // negative and the result is unsigned.
-    if (DstBitWidth > SrcBitWidth) {
-      OverflowError = (SrcTySigned && !DstTySigned && SrcVal.isNegative());
-      Result = (SrcTySigned ? SrcVal.sext(DstBitWidth)
-                            : SrcVal.zext(DstBitWidth));
-
-    // A same-width change can overflow if the top bit disagrees.
-    } else if (DstBitWidth == SrcBitWidth) {
-      OverflowError = (SrcTySigned != DstTySigned && SrcVal.isNegative());
-      Result = SrcVal;
-
-    // A truncation can overflow if the value changes.
-    } else {
-      Result = SrcVal.trunc(DstBitWidth);
-      APInt Ext = (DstTySigned ? Result.sext(SrcBitWidth)
-                               : Result.zext(SrcBitWidth));
-      OverflowError = (SrcVal != Ext);
-    }
+    Result = SrcVal.trunc(DstBitWidth);
+    APInt Ext = (DstTySigned ? Result.sext(SrcBitWidth)
+                             : Result.zext(SrcBitWidth));
+    OverflowError = (SrcVal != Ext);
   }
 
   // Check for overflow.
@@ -819,25 +804,19 @@ constantFoldAndCheckIntegerConversions(BuiltinInst *BI,
                  DstTySigned, DstTy, SrcAsString);
       }
     } else {
-      if (Builtin.ID == BuiltinValueKind::SUCheckedConversion) {
+      // Try to print user-visible types if they are available.
+      if (!UserSrcTy.isNull()) {
         diagnose(M.getASTContext(), Loc.getSourceLoc(),
-                 diag::integer_conversion_sign_error,
-                 UserDstTy.isNull() ? DstTy : UserDstTy);
-      } else {
-        // Try to print user-visible types if they are available.
-        if (!UserSrcTy.isNull()) {
-          diagnose(M.getASTContext(), Loc.getSourceLoc(),
-                   diag::integer_conversion_overflow,
-                   UserSrcTy, UserDstTy);
+                 diag::integer_conversion_overflow,
+                 UserSrcTy, UserDstTy);
 
-        // Otherwise, print the Builtin Types.
-        } else {
-          // Since builtin types are sign-agnostic, print the signedness
-          // separately.
-          diagnose(M.getASTContext(), Loc.getSourceLoc(),
-                   diag::integer_conversion_overflow_builtin_types,
-                   SrcTySigned, SrcTy, DstTySigned, DstTy);
-        }
+      // Otherwise, print the Builtin Types.
+      } else {
+        // Since builtin types are sign-agnostic, print the signedness
+        // separately.
+        diagnose(M.getASTContext(), Loc.getSourceLoc(),
+                 diag::integer_conversion_overflow_builtin_types,
+                 SrcTySigned, SrcTy, DstTySigned, DstTy);
       }
     }
 
@@ -1220,9 +1199,7 @@ case BuiltinValueKind::id:
   case BuiltinValueKind::SToSCheckedTrunc:
   case BuiltinValueKind::UToUCheckedTrunc:
   case BuiltinValueKind::SToUCheckedTrunc:
-  case BuiltinValueKind::UToSCheckedTrunc:
-  case BuiltinValueKind::SUCheckedConversion:
-  case BuiltinValueKind::USCheckedConversion: {
+  case BuiltinValueKind::UToSCheckedTrunc: {
     return constantFoldAndCheckIntegerConversions(BI, Builtin, ResultsInError);
   }
 
diff --git a/test/SILOptimizer/peephole_trunc_and_ext.sil b/test/SILOptimizer/peephole_trunc_and_ext.sil
diff --git a/test/SILOptimizer/sil_combine.sil b/test/SILOptimizer/sil_combine.sil
