---

yaml
---
r: 294333
b: refs/heads/tensorflow
c: c957c50
h: refs/heads/master
i:
  294331: e4bea9a

Author: eeckstein

[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: 6cca050fd9a51b6fa41e1efffe044de11d6a18dd
+refs/heads/tensorflow: c957c50e28974ed264b14fe832a95421099cbd65
 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/CMakeLists.txt

@@ -123,7 +123,7 @@ set_property(CACHE SWIFT_ANALYZE_CODE_COVERAGE PROPERTY
 # SWIFT_VERSION is deliberately /not/ cached so that an existing build directory
 # can be reused when a new version of Swift comes out (assuming the user hasn't
 # manually set it as part of their own CMake configuration).
-set(SWIFT_VERSION "5.1")
+set(SWIFT_VERSION "5.0")
 
 set(SWIFT_VENDOR "" CACHE STRING
     "The vendor name of the Swift compiler")

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

@@ -625,7 +625,7 @@ ERROR(serialization_missing_dependencies,Fatal,
 ERROR(serialization_circular_dependency,Fatal,
       "circular dependency between modules '%0' and %1",
       (StringRef, Identifier))
-ERROR(serialization_missing_underlying_module,Fatal,
+ERROR(serialization_missing_shadowed_module,Fatal,
       "cannot load underlying module for %0", (Identifier))
 ERROR(serialization_name_mismatch,Fatal,
       "cannot load module '%0' as '%1'", (StringRef, StringRef))

branches/tensorflow/include/swift/AST/DiagnosticsSema.def

@@ -57,8 +57,8 @@ class ModuleFile
   /// A reference back to the AST representation of the file.
   FileUnit *FileContext = nullptr;
 
-  /// The module that this module is an overlay of, if any.
-  ModuleDecl *UnderlyingModule = nullptr;
+  /// The module shadowed by this module, if any.
+  ModuleDecl *ShadowedModule = nullptr;
 
   /// The module file data.
   std::unique_ptr<llvm::MemoryBuffer> ModuleInputBuffer;
@@ -702,8 +702,8 @@ class ModuleFile
     return Dependencies;
   }
 
-  /// The module that this module is an overlay for, if any.
-  ModuleDecl *getUnderlyingModule() const { return UnderlyingModule; }
+  /// The module shadowed by this module, if any.
+  ModuleDecl *getShadowedModule() const { return ShadowedModule; }
 
   /// Searches the module's top-level decls for the given identifier.
   void lookupValue(DeclName name, SmallVectorImpl<ValueDecl*> &results);

branches/tensorflow/include/swift/Serialization/ModuleFile.h

@@ -52,7 +52,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 490; // dependency directories
+const uint16_t SWIFTMODULE_VERSION_MINOR = 491; // mangled class names as vtable keys
 
 using DeclIDField = BCFixed<31>;
 

branches/tensorflow/include/swift/Serialization/ModuleFormat.h

@@ -61,10 +61,7 @@ class SerializedSILLoader {
   lookupSILFunction(StringRef Name, bool declarationOnly = false,
                     Optional<SILLinkage> linkage = None);
   bool hasSILFunction(StringRef Name, Optional<SILLinkage> linkage = None);
-  SILVTable *lookupVTable(Identifier Name);
-  SILVTable *lookupVTable(const ClassDecl *C) {
-    return lookupVTable(C->getName());
-  }
+  SILVTable *lookupVTable(const ClassDecl *C);
   SILWitnessTable *lookupWitnessTable(SILWitnessTable *C);
   SILDefaultWitnessTable *lookupDefaultWitnessTable(SILDefaultWitnessTable *C);
 

branches/tensorflow/include/swift/Serialization/SerializedSILLoader.h

@@ -43,7 +43,7 @@ enum class Status {
   MissingDependency,
 
   /// The module file is an overlay for a Clang module, which can't be found.
-  MissingUnderlyingModule,
+  MissingShadowedModule,
 
   /// The module file depends on a module that is still being loaded, i.e.
   /// there is a circular dependency.

branches/tensorflow/include/swift/Serialization/Validation.h

@@ -2559,7 +2559,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     }
 
     // If we won't be able to provide a result, bail out.
-    if (!ConstructorType && addName.empty() && !needInit)
+    if (MemberType->hasError() && addName.empty() && !needInit)
       return;
 
     // Add the constructor, possibly including any default arguments.
@@ -2577,6 +2577,8 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
         Builder.addTextChunk("init");
       } else if (!addName.empty()) {
         Builder.addTextChunk(addName.str());
+      } else {
+        assert(!MemberType->hasError() && "will insert empty result");
       }
 
       if (!ConstructorType) {

branches/tensorflow/lib/IDE/CodeCompletion.cpp

@@ -494,10 +494,8 @@ struct ImmutableAddressUseVerifier {
     while (!worklist.empty()) {
       auto *use = worklist.pop_back_val();
       auto *inst = use->getUser();
-
       if (inst->isTypeDependentOperand(*use))
         continue;
-
       switch (inst->getKind()) {
       case SILInstructionKind::MarkDependenceInst:
       case SILInstructionKind::LoadBorrowInst:
@@ -514,14 +512,6 @@ struct ImmutableAddressUseVerifier {
         //
         // TODO: Can we do better?
         break;
-      case SILInstructionKind::BranchInst:
-      case SILInstructionKind::CondBranchInst:
-        // We do not analyze through branches and cond_br instructions and just
-        // assume correctness. This is so that we can avoid having to analyze
-        // through phi loops and since we want to remove address phis (meaning
-        // that this eventually would never be able to happen). Once that
-        // changes happens, we should remove this code and just error below.
-        break;
       case SILInstructionKind::ApplyInst:
       case SILInstructionKind::TryApplyInst:
       case SILInstructionKind::PartialApplyInst:
@@ -587,8 +577,7 @@ struct ImmutableAddressUseVerifier {
         }
         break;
       default:
-        llvm::errs() << "Unhandled, unexpected instruction: " << *inst;
-        llvm_unreachable("invoking standard assertion failure");
+        llvm_unreachable("Unhandled unexpected instruction");
         break;
       }
     }

branches/tensorflow/lib/SIL/SILVerifier.cpp

@@ -235,6 +235,7 @@ class SILCombiner :
   SILInstruction *visitUpcastInst(UpcastInst *UCI);
   SILInstruction *optimizeLoadFromStringLiteral(LoadInst *LI);
   SILInstruction *visitLoadInst(LoadInst *LI);
+  SILInstruction *visitStoreInst(StoreInst *si);
   SILInstruction *visitIndexAddrInst(IndexAddrInst *IA);
   SILInstruction *visitAllocStackInst(AllocStackInst *AS);
   SILInstruction *visitAllocRefInst(AllocRefInst *AR);

branches/tensorflow/lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -586,6 +586,79 @@ SILInstruction *SILCombiner::optimizeLoadFromStringLiteral(LoadInst *LI) {
   return Builder.createIntegerLiteral(LI->getLoc(), LI->getType(), str[index]);
 }
 
+SILInstruction *SILCombiner::visitStoreInst(StoreInst *si) {
+  auto *f = si->getFunction();
+  assert(f->getConventions().useLoweredAddresses() &&
+         "These optimizations assume that opaque values are not enabled");
+
+  // (store (struct_element_addr addr) object)
+  //   ->
+  // (store addr (struct object))
+
+  // If our store's destination is not a struct_element_addr, bail early.
+  auto *sea = dyn_cast<StructElementAddrInst>(si->getDest());
+  if (!sea)
+    return nullptr;
+
+  // Ok, we have at least one struct_element_addr. Canonicalize the underlying
+  // store.
+  Builder.setInsertionPoint(si);
+  SILLocation loc = si->getLoc();
+
+  auto &mod = si->getModule();
+  SILValue result = si->getSrc();
+  SILValue iterAddr = sea->getOperand();
+  SILValue storeAddr;
+  while (true) {
+    SILType iterAddrType = iterAddr->getType();
+
+    // If our aggregate has unreferenced storage then we can never prove if it
+    // actually has a single field.
+    if (iterAddrType.aggregateHasUnreferenceableStorage())
+      break;
+
+    auto *decl = iterAddrType.getStructOrBoundGenericStruct();
+    assert(
+        !decl->isResilient(mod.getSwiftModule(), f->getResilienceExpansion()) &&
+        "This code assumes resilient structs can not have fragile fields. If "
+        "this assert is hit, this has been changed. Please update this code.");
+
+    // NOTE: If this is ever changed to support enums, we must check for address
+    // only types here. For structs we do not have to check since a single
+    // element struct with a loadable element can never be address only. We
+    // additionally do not have to worry about our input value being address
+    // only since we are storing into it.
+    auto props = decl->getStoredProperties();
+    if (std::next(props.begin()) != props.end())
+      break;
+
+    // Update the store location now that we know it is safe.
+    storeAddr = iterAddr;
+
+    // Otherwise, create the struct.
+    result = Builder.createStruct(loc, iterAddrType.getObjectType(), result);
+
+    // See if we have another struct_element_addr we can strip off. If we don't
+    // then this as much as we can promote.
+    sea = dyn_cast<StructElementAddrInst>(sea->getOperand());
+    if (!sea)
+      break;
+    iterAddr = sea->getOperand();
+  }
+
+  // If we failed to create any structs, bail.
+  if (result == si->getSrc())
+    return nullptr;
+
+  // Then create a new store, storing the value into the relevant computed
+  // address.
+  Builder.createStore(loc, result, storeAddr,
+                      StoreOwnershipQualifier::Unqualified);
+
+  // Then eliminate the original store.
+  return eraseInstFromFunction(*si);
+}
+
 SILInstruction *SILCombiner::visitLoadInst(LoadInst *LI) {
   // (load (upcast-ptr %x)) -> (upcast-ref (load %x))
   Builder.setCurrentDebugScope(LI->getDebugScope());

branches/tensorflow/lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp

@@ -309,84 +309,6 @@ splitAggregateLoad(LoadInst *loadInst, CanonicalizeInstruction &pass) {
   return killInstAndIncidentalUses(loadInst, nextII, pass);
 }
 
-// Given a store within a single property struct, recursively form the parent
-// struct values and promote the store to the outer struct type.
-//
-// (store (struct_element_addr %base) object)
-//   ->
-// (store %base (struct object))
-static SILBasicBlock::iterator
-broadenSingleElementStores(StoreInst *storeInst,
-                           CanonicalizeInstruction &pass) {
-  // Keep track of the next iterator after any newly added or to-be-deleted
-  // instructions. This must be valid regardless of whether the pass immediately
-  // deletes the instructions or simply records them for later deletion.
-  auto nextII = std::next(storeInst->getIterator());
-
-  // Bail if the store's destination is not a struct_element_addr.
-  auto *sea = dyn_cast<StructElementAddrInst>(storeInst->getDest());
-  if (!sea)
-    return nextII;
-
-  auto *f = storeInst->getFunction();
-
-  // Continue up the struct_element_addr chain, as long as each struct only has
-  // a single property, creating StoreInsts along the way.
-  SILBuilderWithScope builder(storeInst);
-
-  SILValue result = storeInst->getSrc();
-  SILValue baseAddr = sea->getOperand();
-  SILValue storeAddr;
-  while (true) {
-    SILType baseAddrType = baseAddr->getType();
-
-    // If our aggregate has unreferenced storage then we can never prove if it
-    // actually has a single field.
-    if (baseAddrType.aggregateHasUnreferenceableStorage())
-      break;
-
-    auto *decl = baseAddrType.getStructOrBoundGenericStruct();
-    assert(
-      !decl->isResilient(f->getModule().getSwiftModule(),
-                         f->getResilienceExpansion()) &&
-        "This code assumes resilient structs can not have fragile fields. If "
-        "this assert is hit, this has been changed. Please update this code.");
-
-    // NOTE: If this is ever changed to support enums, we must check for address
-    // only types here. For structs we do not have to check since a single
-    // element struct with a loadable element can never be address only. We
-    // additionally do not have to worry about our input value being address
-    // only since we are storing into it.
-    auto props = decl->getStoredProperties();
-    if (std::next(props.begin()) != props.end())
-      break;
-
-    // Update the store location now that we know it is safe.
-    storeAddr = baseAddr;
-
-    // Otherwise, create the struct.
-    result = builder.createStruct(storeInst->getLoc(),
-                                  baseAddrType.getObjectType(), result);
-
-    // See if we have another struct_element_addr we can strip off. If we don't
-    // then this as much as we can promote.
-    sea = dyn_cast<StructElementAddrInst>(sea->getOperand());
-    if (!sea)
-      break;
-    baseAddr = sea->getOperand();
-  }
-  // If we failed to create any structs, bail.
-  if (result == storeInst->getSrc())
-    return nextII;
-
-  // Store the new struct-wrapped value into the final base address.
-  builder.createStore(storeInst->getLoc(), result, storeAddr,
-                      storeInst->getOwnershipQualifier());
-
-  // Erase the original store.
-  return killInstruction(storeInst, nextII, pass);
-}
-
 //===----------------------------------------------------------------------===//
 //                            Top-Level Entry Point
 //===----------------------------------------------------------------------===//
@@ -399,9 +321,6 @@ CanonicalizeInstruction::canonicalize(SILInstruction *inst) {
   if (auto *loadInst = dyn_cast<LoadInst>(inst))
     return splitAggregateLoad(loadInst, *this);
 
-  if (auto *storeInst = dyn_cast<StoreInst>(inst))
-    return broadenSingleElementStores(storeInst, *this);
-
   // Skip ahead.
   return std::next(inst->getIterator());
 }

branches/tensorflow/lib/SILOptimizer/Utils/CanonicalizeInstruction.cpp

@@ -2010,14 +2010,14 @@ ModuleDecl *ModuleFile::getModule(ArrayRef<Identifier> name,
   // FIXME: duplicated from NameBinder::getModule
   if (name.size() == 1 &&
       name.front() == FileContext->getParentModule()->getName()) {
-    if (!UnderlyingModule && allowLoading) {
+    if (!ShadowedModule && allowLoading) {
       auto importer = getContext().getClangModuleLoader();
       assert(importer && "no way to import shadowed module");
-      UnderlyingModule = importer->loadModule(SourceLoc(),
-                                              {{name.front(), SourceLoc()}});
+      ShadowedModule = importer->loadModule(SourceLoc(),
+                                            { { name.front(), SourceLoc() } });
     }
 
-    return UnderlyingModule;
+    return ShadowedModule;
   }
 
   SmallVector<ImportDecl::AccessPathElement, 4> importPath;

branches/tensorflow/lib/Serialization/Deserialization.cpp

@@ -2779,10 +2779,10 @@ SILVTable *SILDeserializer::readVTable(DeclID VId) {
   return vT;
 }
 
-SILVTable *SILDeserializer::lookupVTable(Identifier Name) {
+SILVTable *SILDeserializer::lookupVTable(StringRef MangledClassName) {
   if (!VTableList)
     return nullptr;
-  auto iter = VTableList->find(Name.str());
+  auto iter = VTableList->find(MangledClassName);
   if (iter == VTableList->end())
     return nullptr;
 

branches/tensorflow/lib/Serialization/DeserializeSIL.cpp

@@ -141,7 +141,7 @@ namespace swift {
     SILFunction *lookupSILFunction(StringRef Name,
                                    bool declarationOnly = false);
     bool hasSILFunction(StringRef Name, Optional<SILLinkage> Linkage = None);
-    SILVTable *lookupVTable(Identifier Name);
+    SILVTable *lookupVTable(StringRef MangledClassName);
     SILWitnessTable *lookupWitnessTable(SILWitnessTable *wt);
     SILDefaultWitnessTable *
     lookupDefaultWitnessTable(SILDefaultWitnessTable *wt);

branches/tensorflow/lib/Serialization/DeserializeSIL.h

@@ -1570,10 +1570,10 @@ Status ModuleFile::associateWithFileContext(FileUnit *file,
     }
     auto module = getModule(modulePath, /*allowLoading*/true);
     if (!module || module->failedToLoad()) {
-      // If we're missing the module we're an overlay for, treat that specially.
+      // If we're missing the module we're shadowing, treat that specially.
       if (modulePath.size() == 1 &&
           modulePath.front() == file->getParentModule()->getName()) {
-        return error(Status::MissingUnderlyingModule);
+        return error(Status::MissingShadowedModule);
       }
 
       // Otherwise, continue trying to load dependencies, so that we can list
@@ -1720,10 +1720,10 @@ TypeDecl *ModuleFile::lookupNestedType(Identifier name,
     }
   }
 
-  if (!UnderlyingModule)
+  if (!ShadowedModule)
     return nullptr;
 
-  for (FileUnit *file : UnderlyingModule->getFiles())
+  for (FileUnit *file : ShadowedModule->getFiles())
     if (auto *nestedType = file->lookupNestedType(name, parent))
       return nestedType;
 
@@ -2195,8 +2195,8 @@ ModuleFile::getOpaqueReturnTypeDecls(SmallVectorImpl<OpaqueTypeDecl *> &results)
 }
 
 void ModuleFile::getDisplayDecls(SmallVectorImpl<Decl *> &results) {
-  if (UnderlyingModule)
-    UnderlyingModule->getDisplayDecls(results);
+  if (ShadowedModule)
+    ShadowedModule->getDisplayDecls(results);
 
   PrettyStackTraceModuleFile stackEntry(*this);
   getImportDecls(results);