---

yaml
---
r: 293743
b: refs/heads/tensorflow
c: ba6582d
h: refs/heads/master
i:
  293741: 299e6d5
  293739: 5c06c3d
  293735: 9fd3e18
  293727: a484558

Author: slavapestov

[refs]

@@ -816,7 +816,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-04-25-a: 22f738a831d43aff2b9c9773bcb65
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-05-08-a: 7d98cc16689baba5c8a3b90a9329bdcc1a12b4e9
 refs/heads/cherr42: a566ad54b073c2c56ac0a705d0a5bed9743135a5
 "refs/heads/codable_test_comment_fix": fc8f6824f7f347e1e8db55bff62db385c5728b5a
-refs/heads/tensorflow: 9587a3a1f643065c4ca853bdcb72b95615f551f9
+refs/heads/tensorflow: ba6582d03f2599993ee44c49511cc75cda6dce26
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-11-a: 8126fd7a652e2f70ad6d76505239e34fb2ef3e1a
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-12-a: b3fd3dd84df6717f2e2e9df58c6d7e99fed57086
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-13-a: 71135119579039dc321c5f65d870050fe36efda2

branches/tensorflow/benchmark/single-source/ObjectiveCBridging.swift

@@ -73,9 +73,6 @@ public let ObjectiveCBridging = [
   BenchmarkInfo(name: "ObjectiveCBridgeFromNSDateComponents",
     runFunction: run_ObjectiveCBridgeFromNSDateComponents, tags: t,
     setUpFunction: setup_dateComponents),
-  BenchmarkInfo(name: "ObjectiveCBridgeASCIIStringFromFile",
-                runFunction: run_ASCIIStringFromFile, tags: ts,
-                setUpFunction: setup_ASCIIStringFromFile),
 ]
 
 #if _runtime(_ObjC)
@@ -712,35 +709,3 @@ public func run_ObjectiveCBridgeFromNSDateComponents(_ N: Int) {
   }
   #endif
 }
-
-var ASCIIStringFromFile:String? = nil
-public func setup_ASCIIStringFromFile() {
-  #if _runtime(_ObjC)
-  let url:URL
-  if #available(OSX 10.12, iOS 10.0, *) {
-    url = FileManager.default.temporaryDirectory.appendingPathComponent(
-      "sphinx.txt"
-    )
-  } else {
-    url = URL(fileURLWithPath: "/tmp/sphinx.txt")
-  }
-  var str = "Sphinx of black quartz judge my vow"
-  str = Array(repeating: str, count: 100).joined()
-  try? str.write(
-    to: url,
-    atomically: true,
-    encoding: .ascii
-  )
-  ASCIIStringFromFile = try! String(contentsOf: url, encoding: .ascii)
-  #endif
-}
-
-@inline(never)
-public func run_ASCIIStringFromFile(_ N: Int) {
-  #if _runtime(_ObjC)
-  for _ in 0 ..< N {
-    blackHole((ASCIIStringFromFile! + "").utf8.count)
-  }
-  #endif
-}
-

branches/tensorflow/include/swift/SIL/SILBuilder.h

@@ -198,13 +198,9 @@ class SILBuilder {
   SILModule &getModule() const { return C.Module; }
   ASTContext &getASTContext() const { return getModule().getASTContext(); }
   const Lowering::TypeLowering &getTypeLowering(SILType T) const {
-    auto expansion = ResilienceExpansion::Maximal;
-    // If there's no current SILFunction, we're inserting into a global
-    // variable initializer.
-    if (F)
-      expansion = F->getResilienceExpansion();
-
-    return getModule().Types.getTypeLowering(T, expansion);
+    // FIXME: Expansion
+    return getModule().Types.getTypeLowering(T,
+                                             ResilienceExpansion::Minimal);
   }
 
   void setOpenedArchetypesTracker(SILOpenedArchetypesTracker *Tracker) {
@@ -2162,7 +2158,15 @@ class SILBuilder {
     if (!SILModuleConventions(M).useLoweredAddresses())
       return true;
 
-    return getTypeLowering(Ty).isLoadable();
+    // FIXME: Just call getTypeLowering() here, and move this code there
+
+    auto expansion = ResilienceExpansion::Maximal;
+    // If there's no current SILFunction, we're inserting into a global
+    // variable initializer.
+    if (F)
+      expansion = F->getResilienceExpansion();
+
+    return M.Types.getTypeLowering(Ty, expansion).isLoadable();
   }
 
   void appendOperandTypeName(SILType OpdTy, llvm::SmallString<16> &Name) {

branches/tensorflow/include/swift/SIL/SILType.h

@@ -252,25 +252,46 @@ class SILType {
 
   /// True if the type, or the referenced type of an address type, is loadable.
   /// This is the opposite of isAddressOnly.
+  bool isLoadable(SILModule &M) const {
+    return !isAddressOnly(M);
+  }
+
+  /// Like isLoadable(SILModule), but specific to a function.
+  ///
+  /// This takes the resilience expansion of the function into account. If the
+  /// type is not loadable in general (because it's resilient), it still might
+  /// be loadable inside a resilient function in the module.
+  /// In other words: isLoadable(SILModule) is the conservative default, whereas
+  /// isLoadable(SILFunction) might give a more optimistic result.
   bool isLoadable(const SILFunction &F) const {
     return !isAddressOnly(F);
   }
 
   /// True if either:
   /// 1) The type, or the referenced type of an address type, is loadable.
   /// 2) The SIL Module conventions uses lowered addresses
+  bool isLoadableOrOpaque(SILModule &M) const;
+
+  /// Like isLoadableOrOpaque(SILModule), but takes the resilience expansion of
+  /// \p F into account (see isLoadable(SILFunction)).
   bool isLoadableOrOpaque(const SILFunction &F) const;
 
   /// True if the type, or the referenced type of an address type, is
   /// address-only. This is the opposite of isLoadable.
+  bool isAddressOnly(SILModule &M) const;
+
+  /// Like isAddressOnly(SILModule), but takes the resilience expansion of
+  /// \p F into account (see isLoadable(SILFunction)).
   bool isAddressOnly(const SILFunction &F) const;
 
   /// True if the type, or the referenced type of an address type, is trivial,
   /// meaning it is loadable and can be trivially copied, moved or detroyed.
   bool isTrivial(const SILFunction &F) const;
 
   /// True if the type, or the referenced type of an address type, is known to
-  /// be a scalar reference-counted type.
+  /// be a scalar reference-counted type. If this is false, then some part of
+  /// the type may be opaque. It may become reference counted later after
+  /// specialization.
   bool isReferenceCounted(SILModule &M) const;
 
   /// Returns true if the referenced type is a function type that never

branches/tensorflow/include/swift/SILOptimizer/Analysis/AliasAnalysis.h

@@ -137,7 +137,7 @@ class AliasAnalysis : public SILAnalysis {
                          SILType TBAAType2 = SILType());  
 
   /// Returns True if memory of type \p T1 and \p T2 may alias.
-  bool typesMayAlias(SILType T1, SILType T2, const SILFunction &F);
+  bool typesMayAlias(SILType T1, SILType T2);
 
   virtual void handleDeleteNotification(SILNode *node) override {
     assert(node->isRepresentativeSILNodeInObject());

branches/tensorflow/include/swift/SILOptimizer/Analysis/ArraySemantic.h

@@ -151,7 +151,7 @@ class ArraySemanticsCall {
 
   /// Replace a call to append(contentsOf: ) with a series of
   /// append(element: ) calls.
-  bool replaceByAppendingValues(SILFunction *AppendFn,
+  bool replaceByAppendingValues(SILModule &M, SILFunction *AppendFn,
                                 SILFunction *ReserveFn,
                                 const llvm::SmallVectorImpl<SILValue> &Vals,
                                 SubstitutionMap Subs);

branches/tensorflow/include/swift/SILOptimizer/Utils/Generics.h

@@ -156,9 +156,8 @@ class ReabstractionInfo {
   }
 
   ResilienceExpansion getResilienceExpansion() const {
-    return (Serialized
-            ? ResilienceExpansion::Minimal
-            : ResilienceExpansion::Maximal);
+    // FIXME: Expansion
+    return ResilienceExpansion::Minimal;
   }
 
   /// Returns true if the \p ParamIdx'th (non-result) formal parameter is

branches/tensorflow/lib/SIL/SILFunction.cpp

@@ -228,34 +228,45 @@ bool SILFunction::isNoReturnFunction() const {
 
 const TypeLowering &
 SILFunction::getTypeLowering(AbstractionPattern orig, Type subst) {
+  // FIXME: Expansion
   return getModule().Types.getTypeLowering(orig, subst,
-                                           getResilienceExpansion());
+                                            ResilienceExpansion::Minimal);
 }
 
 const TypeLowering &SILFunction::getTypeLowering(Type t) const {
-  return getModule().Types.getTypeLowering(t, getResilienceExpansion());
+  // FIXME: Expansion
+  return getModule().Types.getTypeLowering(t, ResilienceExpansion::Minimal);
 }
 
 SILType
 SILFunction::getLoweredType(AbstractionPattern orig, Type subst) const {
+  // FIXME: Expansion
   return getModule().Types.getLoweredType(orig, subst,
-                                          getResilienceExpansion());
+                                          ResilienceExpansion::Minimal);
 }
 
 SILType SILFunction::getLoweredType(Type t) const {
-  return getModule().Types.getLoweredType(t, getResilienceExpansion());
+  // FIXME: Expansion
+  return getModule().Types.getLoweredType(t,
+                                          ResilienceExpansion::Minimal);
 }
 
 SILType SILFunction::getLoweredLoadableType(Type t) const {
-  return getModule().Types.getLoweredLoadableType(t, getResilienceExpansion());
+  // FIXME: Expansion
+  return getModule().Types.getLoweredLoadableType(t,
+                                                  ResilienceExpansion::Minimal);
 }
 
 const TypeLowering &SILFunction::getTypeLowering(SILType type) const {
-  return getModule().Types.getTypeLowering(type, getResilienceExpansion());
+  // FIXME: Expansion
+  return getModule().Types.getTypeLowering(type,
+                                           ResilienceExpansion::Minimal);
 }
 
 bool SILFunction::isTypeABIAccessible(SILType type) const {
-  return getModule().isTypeABIAccessible(type, getResilienceExpansion());
+  // FIXME: Expansion
+  return getModule().isTypeABIAccessible(type,
+                                         ResilienceExpansion::Minimal);
 }
 
 SILBasicBlock *SILFunction::createBasicBlock() {

branches/tensorflow/lib/SIL/SILFunctionType.cpp

@@ -1005,9 +1005,8 @@ static CanSILFunctionType getSILFunctionType(
   // from the function to which the argument is attached.
   if (constant && !constant->isDefaultArgGenerator()) {
     if (auto function = constant->getAnyFunctionRef()) {
-      auto expansion = ResilienceExpansion::Maximal;
-      if (constant->isSerialized())
-        expansion = ResilienceExpansion::Minimal;
+      // FIXME: Expansion
+      auto expansion = ResilienceExpansion::Minimal;
       lowerCaptureContextParameters(M, *function, genericSig, expansion,
                                     inputs);
     }

branches/tensorflow/lib/SIL/SILType.cpp

@@ -81,7 +81,9 @@ SILType SILType::getSILTokenType(const ASTContext &C) {
 }
 
 bool SILType::isTrivial(const SILFunction &F) const {
-  return F.getTypeLowering(*this).isTrivial();
+  // FIXME: Should just call F.getTypeLowering()
+  return F.getModule().Types.getTypeLowering(*this,
+                                      ResilienceExpansion::Minimal).isTrivial();
 }
 
 bool SILType::isReferenceCounted(SILModule &M) const {
@@ -175,13 +177,28 @@ SILType SILType::getEnumElementType(EnumElementDecl *elt, SILModule &M) const {
   return SILType(loweredTy, getCategory());
 }
 
+bool SILType::isLoadableOrOpaque(SILModule &M) const {
+  return isLoadable(M) || !SILModuleConventions(M).useLoweredAddresses();
+}
+
 bool SILType::isLoadableOrOpaque(const SILFunction &F) const {
   SILModule &M = F.getModule();
-  return isLoadable(F) || !SILModuleConventions(M).useLoweredAddresses();
+  return isLoadable(F) ||
+         !SILModuleConventions(M).useLoweredAddresses();
+}
+
+/// True if the type, or the referenced type of an address type, is
+/// address-only. For example, it could be a resilient struct or something of
+/// unknown size.
+bool SILType::isAddressOnly(SILModule &M) const {
+  return M.Types.getTypeLowering(*this, ResilienceExpansion::Minimal)
+    .isAddressOnly();
 }
 
 bool SILType::isAddressOnly(const SILFunction &F) const {
-  return F.getTypeLowering(*this).isAddressOnly();
+  // FIXME: Should just call F.getTypeLowering()
+  return F.getModule().Types.getTypeLowering(*this,
+                                   F.getResilienceExpansion()).isAddressOnly();
 }
 
 SILType SILType::substGenericArgs(SILModule &M,

branches/tensorflow/lib/SILGen/RValue.cpp

@@ -85,7 +85,7 @@ class ExplodeTupleValue
 
   void visitType(CanType formalType, ManagedValue v) {
     // If we have a loadable type that has not been loaded, actually load it.
-    if (!v.getType().isObject() && v.getType().isLoadable(SGF.F)) {
+    if (!v.getType().isObject() && v.getType().isLoadable(SGF.getModule())) {
       if (v.isPlusOne(SGF)) {
         v = SGF.B.createLoadTake(loc, v);
       } else {
@@ -390,7 +390,7 @@ static void verifyHelper(ArrayRef<ManagedValue> values,
   auto result = Optional<ValueOwnershipKind>(ValueOwnershipKind::Any);
   Optional<bool> sameHaveCleanups;
   for (ManagedValue v : values) {
-    assert((!SGF || !v.getType().isLoadable(SGF.get()->F) ||
+    assert((!SGF || !v.getType().isLoadable(SGF.get()->getModule()) ||
             v.getType().isObject()) &&
            "All loadable values in an RValue must be an object");
 
@@ -803,7 +803,7 @@ SILType RValue::getLoweredType(SILGenFunction &SGF) const & {
 
 SILType RValue::getLoweredImplodedTupleType(SILGenFunction &SGF) const & {
   SILType loweredType = getLoweredType(SGF);
-  if (loweredType.isAddressOnly(SGF.F) &&
+  if (loweredType.isAddressOnly(SGF.getModule()) &&
       SGF.silConv.useLoweredAddresses())
     return loweredType.getAddressType();
   return loweredType.getObjectType();