---

yaml
---
r: 347129
b: refs/heads/master
c: 08b6871
h: refs/heads/master
i:
  347127: 2b55d6a

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: ed8c68d4243b59861bbc9776ee5a6ad77a5cc354
+refs/heads/master: 08b6871abb38b002d9bcdea07361b1574323b468
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/lib/SILOptimizer/Analysis/ArraySemantic.cpp

@@ -168,7 +168,7 @@ ArrayCallKind swift::ArraySemanticsCall::getKind() const {
         llvm::StringSwitch<ArrayCallKind>(Attrs)
             .Case("array.props.isNativeTypeChecked",
                   ArrayCallKind::kArrayPropsIsNativeTypeChecked)
-            .Case("array.init", ArrayCallKind::kArrayInit)
+            .StartsWith("array.init", ArrayCallKind::kArrayInit)
             .Case("array.uninitialized", ArrayCallKind::kArrayUninitialized)
             .Case("array.check_subscript", ArrayCallKind::kCheckSubscript)
             .Case("array.check_index", ArrayCallKind::kCheckIndex)

trunk/lib/SILOptimizer/Transforms/ArrayCountPropagation.cpp

@@ -102,7 +102,7 @@ bool ArrayAllocation::isInitializationWithKnownCount() {
       (ArrayValue = Uninitialized.getArrayValue()))
     return true;
 
-  ArraySemanticsCall Init(Alloc, "array.init");
+  ArraySemanticsCall Init(Alloc, "array.init", /*matchPartialName*/true);
   if (Init &&
       (ArrayCount = Init.getInitializationCount()) &&
       (ArrayValue = Init.getArrayValue()))

trunk/lib/SILOptimizer/Utils/ConstantFolding.cpp

@@ -995,11 +995,14 @@ bool isLossyUnderflow(int srcExponent, uint64_t srcSignificand,
                                   : srcSignificand;
 
   // Compute the significand bits lost due to subnormal form. Note that the
-  // integer part: 1 will use up a significand bit in denormal form.
+  // integer part: 1 will use up a significand bit in subnormal form.
   unsigned additionalLoss = destSem.minExponent - srcExponent + 1;
+  // Lost bits cannot exceed Double.minExponent - Double.significandWidth = 53.
+  // This can happen when truncating from Float80 to Double.
+  assert(additionalLoss <= 53);
 
   // Check whether a set LSB is lost due to subnormal representation.
-  unsigned lostLSBBitMask = (1 << additionalLoss) - 1;
+  uint64_t lostLSBBitMask = ((uint64_t)1 << additionalLoss) - 1;
   return (truncSignificand & lostLSBBitMask);
 }
 

trunk/stdlib/public/core/Array.swift

@@ -802,7 +802,7 @@ extension Array: RangeReplaceableCollection {
   ///     print(emptyArray.isEmpty)
   ///     // Prints "true"
   @inlinable
-  @_semantics("array.init")
+  @_semantics("array.init.empty")
   public init() {
     _buffer = _Buffer()
   }

trunk/stdlib/public/core/ArrayShared.swift

@@ -27,6 +27,7 @@ public struct _DependenceToken {
 /// - Precondition: `storage` is `_ContiguousArrayStorage`.
 @inlinable // FIXME(inline-always)
 @inline(__always)
+@_semantics("array.uninitialized_intrinsic")
 public // COMPILER_INTRINSIC
 func _allocateUninitializedArray<Element>(_  builtinCount: Builtin.Word)
     -> (Array<Element>, Builtin.RawPointer) {

trunk/test/SILOptimizer/diagnostic_constant_propagation_floats.swift

@@ -171,6 +171,14 @@ func testHexFloatImprecision() {
   // Smallest non-zero number representable in Double.
   let d2: Double = 0x0.0000000000001p-1022
   _blackHole(d2)
+  let d3: Double = 0x1p-1074
+  _blackHole(d3)
+
+  // Test the case where conversion results in subnormality in the destination.
+  let d4: Float = 0x1p-149
+  _blackHole(d4)
+  let d5: Float = 0x1.8p-149 // expected-warning {{'0x1.8p-149' loses precision during conversion to 'Float}}
+  _blackHole(d5)
 
   // All warnings are disabled during explict conversions.
   _blackHole(Float(0x1.000002p-126))

trunk/test/SILOptimizer/diagnostic_constant_propagation_floats_x86.swift

@@ -67,11 +67,20 @@ func testFloatConvertUnderflow() {
   let d4: Double = 5E-324  // expected-warning {{'5E-324' underflows and loses precision during conversion to 'Double'}}
   _blackHole(d4)
 
+  let e4: Float80 = 0x1p-16445
+  _blackHole(e4)
+
   // FIXME: if a number is so tiny that it underflows even Float80,
   // nothing is reported
   let e1: Float80 = 0x1p-16446
   _blackHole(e1)
 
+  // Test the case where conversion results in subnormality in the destination.
+  let e2: Double = 0x1p-1074
+  _blackHole(e2)
+  let e3: Double = 0x11p-1074 // expected-warning {{'0x11p-1074' underflows and loses precision during conversion to 'Double'}}
+  _blackHole(e3)
+
   // All warnings are disabled during explict conversions
   _blackHole(Float(1E-400))
   _blackHole(Double(1E-309))