Fixed regressions in tests caused by changes upstream.

The relevant PR is #20200

Author: bgogul

lib/SILOptimizer/Mandatory/TFConstExpr.cpp

@@ -457,17 +457,38 @@ ConstExprFunctionState::computeConstantValueBuiltin(BuiltinInst *inst) {
       auto dstBitWidth =
           builtin.Types[1]->castTo<BuiltinIntegerType>()->getGreatestWidth();
 
-      APInt result = operandVal.trunc(dstBitWidth);
+      // Get source type and bit width.
+      auto SrcTy = builtin.Types[0]->castTo<AnyBuiltinIntegerType>();
+      assert((srcSigned || !isa<BuiltinIntegerLiteralType>(SrcTy)) &&
+             "only the signed intrinsics can be used with integer literals");
+
+      assert((dstBitWidth < srcBitWidth || !SrcTy->getWidth().isFixedWidth()) &&
+             "preconditions on builtin trunc operations should prevent"
+             "fixed-width truncations that actually extend");
+      APInt result;
+      bool overflowed;
+      if (dstBitWidth > srcBitWidth) {
+        // The only way a true extension can overflow is if the value is
+        // negative and the result is unsigned.
+        overflowed = (srcSigned && !dstSigned && operandVal.isNegative());
+        result =
+            srcSigned ? operandVal.sext(dstBitWidth) : operandVal.zext(dstBitWidth);
+      } else if (dstBitWidth == srcBitWidth) {
+        // A same-width change can overflow if the top bit disagrees.
+        overflowed = (srcSigned != dstSigned && operandVal.isNegative());
+      } else {
+        // Truncate the result and check for overflow.
+        result = operandVal.trunc(dstBitWidth);
 
-      // Compute the overflow by re-extending the value back to its source and
-      // checking for loss of value.
-      APInt reextended =
+        // Compute the overflow by re-extending the value back to its source and
+        // checking for loss of value.
+        APInt reextended =
           dstSigned ? result.sext(srcBitWidth) : result.zext(srcBitWidth);
-      bool overflowed = (operandVal != reextended);
-
-      if (builtin.ID == BuiltinValueKind::UToSCheckedTrunc)
-        overflowed |= result.isSignBitSet();
+        overflowed = (operandVal != reextended);
 
+        if (builtin.ID == BuiltinValueKind::UToSCheckedTrunc)
+          overflowed |= result.isSignBitSet();
+      }
       if (overflowed)
         return evaluator.getUnknown(SILValue(inst), UnknownReason::Overflow);
 

lib/SILOptimizer/Mandatory/TFDifferentiation.cpp

@@ -1619,9 +1619,9 @@ static void convertIntToIndirectExpressible(intmax_t scalar,
   auto *intLitTypeDecl = intLitTy->getAnyNominal();
   assert(intLitTypeDecl);
   // %1 = float_literal $Builtin.FPIEEE80, <value>
-  auto builtinIntegerTy = SILType::getBuiltinIntegerType(2048, astCtx);
-  auto builtinInteger = builder.createIntegerLiteral(
-      loc, builtinIntegerTy, APInt(2048, scalar));
+  auto builtinIntegerLiteralTy = SILType::getBuiltinIntegerLiteralType(astCtx);
+  auto builtinInteger =
+      builder.createIntegerLiteral(loc, builtinIntegerLiteralTy, scalar);
   // %2 = metatype $@thin <target type>.IntegerLiteralType.Type
   auto intLitMetatypeTy = SILType::getPrimitiveObjectType(
       CanMetatypeType::get(intLitTy, MetatypeRepresentation::Thick));