Merge pull request #2176 from swiftix/master

swiftix · swiftix · commit 46e359041d8f · 2016-04-13T19:16:20.000-07:00
Improve the implementation of pre-specializations
diff --git a/include/swift/Serialization/SerializedSILLoader.h b/include/swift/Serialization/SerializedSILLoader.h
@@ -94,6 +94,7 @@ class SerializedSILLoader {
   SILFunction *
   lookupSILFunction(StringRef Name, bool declarationOnly = false,
                     SILLinkage linkage = SILLinkage::Private);
+  bool hasSILFunction(StringRef Name, SILLinkage linkage = SILLinkage::Private);
   SILVTable *lookupVTable(Identifier Name);
   SILVTable *lookupVTable(const ClassDecl *C) {
     return lookupVTable(C->getName());
diff --git a/lib/SIL/Linker.cpp b/lib/SIL/Linker.cpp
@@ -139,6 +139,10 @@ SILFunction *SILLinkerVisitor::lookupFunction(StringRef Name,
   return NewFn;
 }
 
+/// Process Decl, recursively deserializing any thing Decl may reference.
+bool SILLinkerVisitor::hasFunction(StringRef Name, SILLinkage Linkage) {
+  return  Loader->hasSILFunction(Name, Linkage);
+}
 
 /// Deserialize the VTable mapped to C if it exists and all SIL the VTable
 /// transitively references.
diff --git a/lib/SIL/Linker.h b/lib/SIL/Linker.h
@@ -58,6 +58,10 @@ class SILLinkerVisitor : public SILInstructionVisitor<SILLinkerVisitor, bool> {
   /// this Name.
   SILFunction *lookupFunction(StringRef Name, SILLinkage Linkage);
 
+  /// Process Name, try to check if there is a declaration of a function
+  /// with this Name.
+  bool hasFunction(StringRef Name, SILLinkage Linkage);
+
   /// Process Decl, recursively deserializing any thing that
   /// the SILFunction corresponding to Decl may reference.
   bool processDeclRef(SILDeclRef Decl);
diff --git a/lib/SIL/SILModule.cpp b/lib/SIL/SILModule.cpp
@@ -484,12 +484,48 @@ bool SILModule::linkFunction(StringRef Name, SILModule::LinkingMode Mode) {
 }
 
 SILFunction *SILModule::hasFunction(StringRef Name, SILLinkage Linkage) {
-  assert(!lookUpFunction(Name) && "hasFunction should be only called for "
-                                  "functions that are not contained in the "
-                                  "SILModule yet");
-  return SILLinkerVisitor(*this, getSILLoader(),
-                          SILModule::LinkingMode::LinkNormal)
-      .lookupFunction(Name, Linkage);
+  SILFunction *F = lookUpFunction(Name);
+
+  assert((Linkage == SILLinkage::Public ||
+          Linkage == SILLinkage::PublicExternal) &&
+         "Only a lookup of public functions is supported currently");
+
+  // Nothing to do if the current module has a required function
+  // with a proper linkage.
+  if (F && F->getLinkage() == Linkage)
+    return F;
+
+  assert((!F || F->getLinkage() != Linkage) &&
+         "hasFunction should be only called for functions that are not "
+         "contained  in the SILModule yet or do not have a required linkage");
+  (void)F;
+
+  SILLinkerVisitor Visitor(*this, getSILLoader(),
+                          SILModule::LinkingMode::LinkNormal);
+
+  if (Visitor.hasFunction(Name, Linkage)) {
+    if (!F) {
+      // Load the function.
+      F = Visitor.lookupFunction(Name, Linkage);
+      assert(F && "Function should be present");
+      assert(F->getLinkage() == Linkage &&
+             "SILFunction has a wrong linkage");
+    }
+    // If a function exists already and it is a non-optimizing
+    // compilaiton, simply convert it into an external declaration,
+    // so that a compiled version from the shared library is used.
+    if (F->isDefinition() &&
+        F->getModule().getOptions().Optimization <
+            SILOptions::SILOptMode::Optimize) {
+      F->convertToDeclaration();
+    }
+    if (F->isExternalDeclaration())
+      F->setFragile(IsFragile_t::IsNotFragile);
+    F->setLinkage(Linkage);
+  } else {
+    F = nullptr;
+  }
+  return F;
 }
 
 void SILModule::linkAllWitnessTables() {
diff --git a/lib/SILOptimizer/IPO/UsePrespecialized.cpp b/lib/SILOptimizer/IPO/UsePrespecialized.cpp
@@ -75,6 +75,9 @@ bool UsePrespecialized::replaceByPrespecialized(SILFunction &F) {
     if (!ReferencedF)
       continue;
 
+    DEBUG(llvm::dbgs() << "Trying to use specialized function for:\n";
+          AI.getInstruction()->dumpInContext());
+
     // Check if it is a call of a generic function.
     // If this is the case, check if there is a specialization
     // available for it already and use this specialization
@@ -114,12 +117,22 @@ bool UsePrespecialized::replaceByPrespecialized(SILFunction &F) {
     // If we already have this specialization, reuse it.
     auto PrevF = M.lookUpFunction(ClonedName);
     if (PrevF) {
+      DEBUG(llvm::dbgs() << "Found a specialization: " << ClonedName << "\n");
       if (PrevF->getLinkage() != SILLinkage::SharedExternal)
         NewF = PrevF;
-    } else {
+      else {
+        DEBUG(llvm::dbgs() << "Wrong linkage: " << (int)PrevF->getLinkage()
+                           << "\n");
+      }
+    }
+
+    if (!PrevF || !NewF) {
       // Check for the existence of this function in another module without
       // loading the function body.
       PrevF = lookupPrespecializedSymbol(M, ClonedName);
+      DEBUG(llvm::dbgs()
+            << "Checked if there is a specialization in a different module: "
+            << PrevF << "\n");
       if (!PrevF)
         continue;
       NewF = PrevF;
@@ -128,10 +141,12 @@ bool UsePrespecialized::replaceByPrespecialized(SILFunction &F) {
     if (!NewF)
       continue;
 
+    assert(NewF->isExternalDeclaration() &&
+           "Prespecialized function should be an external declaration");
+
     // An existing specialization was found.
-    DEBUG(
-        llvm::dbgs() << "Found a specialization of " << ReferencedF->getName()
-        << " : " << NewF->getName() << "\n");
+    DEBUG(llvm::dbgs() << "Found a specialization of " << ReferencedF->getName()
+                       << " : " << NewF->getName() << "\n");
 
     auto NewAI = replaceWithSpecializedFunction(AI, NewF, ReInfo);
     AI.getInstruction()->replaceAllUsesWith(NewAI.getInstruction());
diff --git a/lib/SILOptimizer/Utils/Generics.cpp b/lib/SILOptimizer/Utils/Generics.cpp
@@ -41,6 +41,9 @@ ReabstractionInfo::ReabstractionInfo(SILFunction *OrigF,
   if (hasUnboundGenericTypes(InterfaceSubs)) {
     DEBUG(llvm::dbgs() <<
           "    Cannot specialize with unbound interface substitutions.\n");
+    DEBUG(for (auto Sub : ParamSubs) {
+            Sub.dump();
+          });
     return;
   }
   if (hasDynamicSelfTypes(InterfaceSubs)) {
@@ -167,8 +170,12 @@ SILFunction *GenericFuncSpecializer::lookupSpecialization() {
     assert(ReInfo.getSpecializedType()
            == SpecializedF->getLoweredFunctionType() &&
            "Previously specialized function does not match expected type.");
+    DEBUG(llvm::dbgs() << "Found an existing specialization for: " << ClonedName
+                       << "\n");
     return SpecializedF;
   }
+  DEBUG(llvm::dbgs() << "Could not find an existing specialization for: "
+                     << ClonedName << "\n");
   return nullptr;
 }
 
@@ -400,7 +407,8 @@ void swift::trySpecializeApplyOfGeneric(
   auto *F = Apply.getInstruction()->getFunction();
   auto *RefF = cast<FunctionRefInst>(Apply.getCallee())->getReferencedFunction();
 
-  DEBUG(llvm::dbgs() << "  ApplyInst: " << *Apply.getInstruction());
+  DEBUG(llvm::dbgs() << "  ApplyInst:\n";
+        Apply.getInstruction()->dumpInContext());
 
   // If the caller is fragile but the callee is not, bail out.
   // Specializations have shared linkage, which means they do
@@ -470,6 +478,9 @@ void swift::trySpecializeApplyOfGeneric(
            == SpecializedF->isFragile() &&
            "Previously specialized function does not match expected "
            "resilience level.");
+    // Even if the pre-specialization exists already, try to preserve it
+    // if it is whitelisted.
+    linkSpecialization(M, SpecializedF);
   } else {
     SpecializedF = FuncSpecializer.tryCreateSpecialization();
     if (!SpecializedF)
@@ -534,8 +545,29 @@ void swift::trySpecializeApplyOfGeneric(
 // This uses the SIL linker to checks for the does not load the body of the pres
 // =============================================================================
 
+static void keepSpecializationAsPublic(SILFunction *F) {
+  DEBUG(auto DemangledNameString =
+            swift::Demangle::demangleSymbolAsString(F->getName());
+        StringRef DemangledName = DemangledNameString;
+        llvm::dbgs() << "Keep specialization public: " << DemangledName << " : "
+                     << F->getName() << "\n");
+  // Make it public, so that others can refer to it.
+  //
+  // NOTE: This function may refer to non-public symbols, which may lead to
+  // problems, if you ever try to inline this function. Therefore, these
+  // specializations should only be used to refer to them, but should never
+  // be inlined!  The general rule could be: Never inline specializations
+  // from stdlib!
+  //
+  // NOTE: Making these specializations public at this point breaks
+  // some optimizations. Therefore, just mark the function.
+  // DeadFunctionElimination pass will check if the function is marked
+  // and preserve it if required.
+  F->setKeepAsPublic(true);
+}
+
 /// Link a specialization for generating prespecialized code.
-/// 
+///
 /// For now, it is performed only for specializations in the
 /// standard library. But in the future, one could think of
 /// maintaining a cache of optimized specializations.
@@ -545,34 +577,14 @@ void swift::trySpecializeApplyOfGeneric(
 /// the library, but only used only by client code compiled at -Onone. They
 /// should be never inlined.
 static bool linkSpecialization(SILModule &M, SILFunction *F) {
+  if (F->isKeepAsPublic())
+    return true;
   // Do not remove functions from the white-list. Keep them around.
   // Change their linkage to public, so that other applications can refer to it.
-
   if (M.getOptions().Optimization >= SILOptions::SILOptMode::Optimize &&
-      F->getLinkage() != SILLinkage::Public &&
       F->getModule().getSwiftModule()->getName().str() == SWIFT_ONONE_SUPPORT) {
-    if (F->getLinkage() != SILLinkage::Public &&
-        isWhitelistedSpecialization(F->getName())) {
-
-      DEBUG(
-        auto DemangledNameString =
-          swift::Demangle::demangleSymbolAsString(F->getName());
-        StringRef DemangledName = DemangledNameString;
-        llvm::dbgs() << "Keep specialization: " << DemangledName << " : "
-                     << F->getName() << "\n");
-      // Make it public, so that others can refer to it.
-      //
-      // NOTE: This function may refer to non-public symbols, which may lead to
-      // problems, if you ever try to inline this function. Therefore, these
-      // specializations should only be used to refer to them, but should never
-      // be inlined!  The general rule could be: Never inline specializations
-      // from stdlib!
-      //
-      // NOTE: Making these specializations public at this point breaks
-      // some optimizations. Therefore, just mark the function.
-      // DeadFunctionElimination pass will check if the function is marked
-      // and preserve it if required.
-      F->setKeepAsPublic(true);
+    if (isWhitelistedSpecialization(F->getName())) {
+      keepSpecializationAsPublic(F);
       return true;
     }
   }
@@ -607,7 +619,10 @@ bool swift::isWhitelistedSpecialization(StringRef SpecName) {
 
   StringRef DemangledName = DemangledNameString;
 
+  DEBUG(llvm::dbgs() << "Check if whitelisted: " << DemangledName << "\n");
+
   auto pos = DemangledName.find("generic ", 0);
+  auto oldpos = pos;
   if (pos == StringRef::npos)
     return false;
 
@@ -618,11 +633,22 @@ bool swift::isWhitelistedSpecialization(StringRef SpecName) {
   buffer << STDLIB_NAME <<'.';
 
   StringRef OfStr = buffer.str();
-
-  pos = DemangledName.find(OfStr, pos);
-
-  if (pos == StringRef::npos)
-    return false;
+  DEBUG(llvm::dbgs() << "Check substring: " << OfStr << "\n");
+
+  pos = DemangledName.find(OfStr, oldpos);
+
+  if (pos == StringRef::npos) {
+    // Create "of (extension in Swift).Swift"
+    llvm::SmallString<64> OfString;
+    llvm::raw_svector_ostream buffer(OfString);
+    buffer << "of (extension in " << STDLIB_NAME << "):";
+    buffer << STDLIB_NAME << '.';
+    OfStr = buffer.str();
+    pos = DemangledName.find(OfStr, oldpos);
+    DEBUG(llvm::dbgs() << "Check substring: " << OfStr << "\n");
+    if (pos == StringRef::npos)
+      return false;
+  }
 
   pos += OfStr.size();
 
@@ -659,8 +685,10 @@ SILFunction *swift::lookupPrespecializedSymbol(SILModule &M,
                                                StringRef FunctionName) {
   // First check if the module contains a required specialization already.
   auto *Specialization = M.lookUpFunction(FunctionName);
-  if (Specialization)
-    return Specialization;
+  if (Specialization) {
+    if (Specialization->getLinkage() == SILLinkage::PublicExternal)
+      return Specialization;
+  }
 
   // Then check if the required specialization can be found elsewhere.
   Specialization = lookupExistingSpecialization(M, FunctionName);
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
@@ -1798,6 +1798,68 @@ SILFunction *SILDeserializer::lookupSILFunction(SILFunction *InFunc) {
   return Func;
 }
 
+/// Check for existence of a function with a given name and required linkage.
+/// This function is modelled after readSILFunction. But it does not
+/// create a SILFunction object.
+bool SILDeserializer::hasSILFunction(StringRef Name,
+                                     SILLinkage Linkage) {
+  if (!FuncTable)
+    return false;
+  auto iter = FuncTable->find(Name);
+  if (iter == FuncTable->end())
+    return false;
+
+  // There is a function with the required name.
+  // Find out which linkage it has.
+  auto FID = *iter;
+  auto &cacheEntry = Funcs[FID-1];
+  if (cacheEntry.isFullyDeserialized() ||
+      (cacheEntry.isDeserialized()))
+    return cacheEntry.get()->getLinkage() == Linkage ||
+           Linkage == SILLinkage::Private;
+
+  BCOffsetRAII restoreOffset(SILCursor);
+  SILCursor.JumpToBit(cacheEntry.getOffset());
+
+  auto entry = SILCursor.advance(AF_DontPopBlockAtEnd);
+  if (entry.Kind == llvm::BitstreamEntry::Error) {
+    DEBUG(llvm::dbgs() << "Cursor advance error in hasSILFunction.\n");
+    MF->error();
+    return false;
+  }
+
+  SmallVector<uint64_t, 64> scratch;
+  StringRef blobData;
+  unsigned kind = SILCursor.readRecord(entry.ID, scratch, &blobData);
+  assert(kind == SIL_FUNCTION && "expect a sil function");
+  (void)kind;
+
+  // Read function properties only, e.g. its linkage and other attributes.
+  // TODO: If this results in any noticable performance problems, Cache the
+  // linkage to avoid re-reading it from the bitcode each time?
+  TypeID funcTyID;
+  unsigned rawLinkage, isTransparent, isFragile, isThunk, isGlobal,
+    inlineStrategy, effect, numSpecAttrs;
+  ArrayRef<uint64_t> SemanticsIDs;
+  SILFunctionLayout::readRecord(scratch, rawLinkage, isTransparent, isFragile,
+                                isThunk, isGlobal, inlineStrategy, effect,
+                                numSpecAttrs, funcTyID, SemanticsIDs);
+  auto linkage = fromStableSILLinkage(rawLinkage);
+  if (!linkage) {
+    DEBUG(llvm::dbgs() << "invalid linkage code " << rawLinkage
+                       << " for SIL function " << Name << "\n");
+    return false;
+  }
+
+  // Bail if it is not a required linkage.
+  if (linkage.getValue() != Linkage && Linkage != SILLinkage::Private)
+    return false;
+
+  DEBUG(llvm::dbgs() << "Found SIL Function: " << Name << "\n");
+  return true;
+}
+
+
 SILFunction *SILDeserializer::lookupSILFunction(StringRef name,
                                                 bool declarationOnly) {
   if (!FuncTable)
diff --git a/lib/Serialization/DeserializeSIL.h b/lib/Serialization/DeserializeSIL.h
@@ -117,6 +117,7 @@ namespace swift {
     SILFunction *lookupSILFunction(SILFunction *InFunc);
     SILFunction *lookupSILFunction(StringRef Name,
                                    bool declarationOnly = false);
+    bool hasSILFunction(StringRef Name, SILLinkage Linkage);
     SILVTable *lookupVTable(Identifier Name);
     SILWitnessTable *lookupWitnessTable(SILWitnessTable *wt);
     SILDefaultWitnessTable *
diff --git a/lib/Serialization/SerializedSILLoader.cpp b/lib/Serialization/SerializedSILLoader.cpp
@@ -104,6 +104,18 @@ SILFunction *SerializedSILLoader::lookupSILFunction(StringRef Name,
   return retVal;
 }
 
+bool SerializedSILLoader::hasSILFunction(StringRef Name, SILLinkage Linkage) {
+  // It is possible that one module has a declaration of a SILFunction, while
+  // another has the full definition.
+  SILFunction *retVal = nullptr;
+  for (auto &Des : LoadedSILSections) {
+    if (Des->hasSILFunction(Name, Linkage))
+      return true;
+  }
+  return retVal;
+}
+
+
 SILVTable *SerializedSILLoader::lookupVTable(Identifier Name) {
   for (auto &Des : LoadedSILSections) {
     if (auto VT = Des->lookupVTable(Name))
diff --git a/stdlib/public/SwiftOnoneSupport/SwiftOnoneSupport.swift b/stdlib/public/SwiftOnoneSupport/SwiftOnoneSupport.swift

Original file line number	Diff line number	Diff line change
`@@ -139,6 +139,10 @@ SILFunction *SILLinkerVisitor::lookupFunction(StringRef Name,`
`139`	`139`	`return NewFn;`
`140`	`140`	`}`
`141`	`141`
	`142`	`+/// Process Decl, recursively deserializing any thing Decl may reference.`
	`143`	`+bool SILLinkerVisitor::hasFunction(StringRef Name, SILLinkage Linkage) {`
	`144`	`+ return Loader->hasSILFunction(Name, Linkage);`
	`145`	`+}`
`142`	`146`
`143`	`147`	`/// Deserialize the VTable mapped to C if it exists and all SIL the VTable`
`144`	`148`	`/// transitively references.`