Merge pull request #1227 from swiftwasm/master

[pull] swiftwasm from master

Author: pull[bot]

docs/WindowsBuild.md

@@ -79,12 +79,12 @@ git clone https://github.com/compnerd/swift-build swift-build
 ## Acquire ICU, SQLite3, curl, libxml2 and zlib
 
 ```
-python -m pip install --user msrest azure-devops tabulate
-python swift-build\utilities\swift-build.py --build-id ICU --latest-artifacts --filter windows-x64 --download
-python swift-build\utilities\swift-build.py --build-id XML2 --latest-artifacts --filter windows-x64 --download
-python swift-build\utilities\swift-build.py --build-id CURL --latest-artifacts --filter windows-x64 --download
-python swift-build\utilities\swift-build.py --build-id zlib --latest-artifacts --filter windows-x64 --download
-python swift-build\utilities\swift-build.py --build-id SQLite --latest-artifacts --filter windows-x64 --download
+C:\Python27\python.exe -m pip install --user msrest azure-devops tabulate
+C:\Python27\python.exe swift-build\utilities\swift-build.py --build-id ICU --latest-artifacts --filter windows-x64 --download
+C:\Python27\python.exe swift-build\utilities\swift-build.py --build-id XML2 --latest-artifacts --filter windows-x64 --download
+C:\Python27\python.exe swift-build\utilities\swift-build.py --build-id CURL --latest-artifacts --filter windows-x64 --download
+C:\Python27\python.exe swift-build\utilities\swift-build.py --build-id zlib --latest-artifacts --filter windows-x64 --download
+C:\Python27\python.exe swift-build\utilities\swift-build.py --build-id SQLite --latest-artifacts --filter windows-x64 --download
 ```
 
 Extract the zip files, ignoring the top level directory, into `S:/Library`. The directory structure should resemble:

include/swift/SIL/SILModule.h

@@ -595,7 +595,7 @@ class SILModule {
                                       bool deserializeLazily=true);
 
   /// Look up the VTable mapped to the given ClassDecl. Returns null on failure.
-  SILVTable *lookUpVTable(const ClassDecl *C);
+  SILVTable *lookUpVTable(const ClassDecl *C, bool deserializeLazily = true);
 
   /// Attempt to lookup the function corresponding to \p Member in the class
   /// hierarchy of \p Class.

include/swift/SIL/SILVTable.h

@@ -49,13 +49,12 @@ class SILVTableEntry {
   /// The function which implements the method for the class and the entry kind.
   llvm::PointerIntPair<SILFunction *, 2, unsigned> ImplAndKind;
 
+  bool IsNonOverridden;
+
 public:
   enum Kind : uint8_t {
     /// The vtable entry is for a method defined directly in this class.
     Normal,
-    /// The vtable entry is for a method defined directly in this class, and is
-    /// never overridden by subclasses.
-    NormalNonOverridden,
     /// The vtable entry is inherited from the superclass.
     Inherited,
     /// The vtable entry is inherited from the superclass, and overridden
@@ -67,14 +66,19 @@ class SILVTableEntry {
 
   SILVTableEntry() : ImplAndKind(nullptr, Kind::Normal) {}
 
-  SILVTableEntry(SILDeclRef Method, SILFunction *Implementation, Kind TheKind)
-      : Method(Method), ImplAndKind(Implementation, TheKind) {}
+  SILVTableEntry(SILDeclRef Method, SILFunction *Implementation, Kind TheKind,
+                 bool NonOverridden)
+      : Method(Method), ImplAndKind(Implementation, TheKind),
+        IsNonOverridden(NonOverridden) {}
 
   SILDeclRef getMethod() const { return Method; }
 
   Kind getKind() const { return Kind(ImplAndKind.getInt()); }
   void setKind(Kind kind) { ImplAndKind.setInt(kind); }
 
+  bool isNonOverridden() const { return IsNonOverridden; }
+  void setNonOverridden(bool value) { IsNonOverridden = value; }
+
   SILFunction *getImplementation() const { return ImplAndKind.getPointer(); }
 };
 

lib/AST/Type.cpp

@@ -2208,6 +2208,16 @@ getObjCObjectRepresentable(Type type, const DeclContext *dc) {
 static std::pair<ForeignRepresentableKind, ProtocolConformance *>
 getForeignRepresentable(Type type, ForeignLanguage language,
                         const DeclContext *dc) {
+  // Local function that simply produces a failing result.
+  auto failure = []() -> std::pair<ForeignRepresentableKind,
+                                   ProtocolConformance *> {
+    return { ForeignRepresentableKind::None, nullptr };
+  };
+  
+  // If type has an error let's fail early.
+  if (type->hasError())
+    return failure();
+  
   // Look through one level of optional type, but remember that we did.
   bool wasOptional = false;
   if (auto valueType = type->getOptionalObjectType()) {
@@ -2222,12 +2232,6 @@ getForeignRepresentable(Type type, ForeignLanguage language,
       return { representable, nullptr };
   }
 
-  // Local function that simply produces a failing result.
-  auto failure = []() -> std::pair<ForeignRepresentableKind,
-                                   ProtocolConformance *> {
-    return { ForeignRepresentableKind::None, nullptr };
-  };
-
   // Function types.
   if (auto functionType = type->getAs<FunctionType>()) {
     // Cannot handle throwing functions.

lib/ClangImporter/ImportName.cpp

@@ -1423,6 +1423,9 @@ ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,
     case clang::OverloadedOperatorKind::OO_Minus:
     case clang::OverloadedOperatorKind::OO_Star:
     case clang::OverloadedOperatorKind::OO_Slash:
+    case clang::OverloadedOperatorKind::OO_Percent:
+    case clang::OverloadedOperatorKind::OO_Amp:
+    case clang::OverloadedOperatorKind::OO_Pipe:
     case clang::OverloadedOperatorKind::OO_LessLess:
     case clang::OverloadedOperatorKind::OO_GreaterGreater:
     case clang::OverloadedOperatorKind::OO_AmpAmp:

lib/IRGen/ClassMetadataVisitor.h

@@ -21,6 +21,8 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/SubstitutionMap.h"
 #include "swift/SIL/SILDeclRef.h"
+#include "swift/SIL/SILModule.h"
+#include "swift/SIL/SILVTable.h"
 #include "swift/SIL/SILVTableVisitor.h"
 #include "IRGen.h"
 #include "NominalMetadataVisitor.h"
@@ -30,6 +32,15 @@ namespace irgen {
 
 class IRGenModule;
 
+/// Returns true if the given SILVTable entry needs to be reified as a runtime
+/// vtable entry.
+///
+/// Methods that have no overrides, and no ABI constraints that require a
+/// vtable to be present, can be left out of the runtime vtable for classes.
+bool methodRequiresReifiedVTableEntry(IRGenModule &IGM,
+                                      const SILVTable *vtable,
+                                      SILDeclRef method);
+
 /// A CRTP class for laying out class metadata.  Note that this does
 /// *not* handle the metadata template stuff.
 template <class Impl> class ClassMetadataVisitor
@@ -43,9 +54,13 @@ template <class Impl> class ClassMetadataVisitor
 
   /// The most-derived class.
   ClassDecl *const Target;
+        
+  /// SILVTable entry for the class.
+  const SILVTable *VTable;
 
   ClassMetadataVisitor(IRGenModule &IGM, ClassDecl *target)
-    : super(IGM), Target(target) {}
+    : super(IGM), Target(target),
+      VTable(IGM.getSILModule().lookUpVTable(target, /*deserialize*/ false)) {}
 
 public:
   void layout() {
@@ -152,8 +167,15 @@ template <class Impl> class ClassMetadataVisitor
     // Add vtable entries.
     asImpl().addVTableEntries(theClass);
   }
-  
-private:
+
+  friend SILVTableVisitor<Impl>;
+  void addMethod(SILDeclRef declRef) {
+    // Does this method require a reified runtime vtable entry?
+    if (methodRequiresReifiedVTableEntry(IGM, VTable, declRef)) {
+      asImpl().addReifiedVTableEntry(declRef);
+    }
+  }
+        
   void addFieldEntries(Decl *field) {
     if (auto var = dyn_cast<VarDecl>(field)) {
       asImpl().addFieldOffset(var);
@@ -194,7 +216,7 @@ class ClassMetadataScanner : public ClassMetadataVisitor<Impl> {
   void addClassAddressPoint() { addInt32(); }
   void addClassCacheData() { addPointer(); addPointer(); }
   void addClassDataPointer() { addPointer(); }
-  void addMethod(SILDeclRef declRef) {
+  void addReifiedVTableEntry(SILDeclRef declRef) {
     addPointer();
   }
   void addMethodOverride(SILDeclRef baseRef, SILDeclRef declRef) {}

lib/IRGen/GenMeta.cpp

@@ -1437,7 +1437,13 @@ namespace {
     }
 
     void addMethod(SILDeclRef fn) {
-      VTableEntries.push_back(fn);
+      if (methodRequiresReifiedVTableEntry(IGM, VTable, fn)) {
+        VTableEntries.push_back(fn);
+      } else if (getType()->getEffectiveAccess() >= AccessLevel::Public) {
+        // Emit a stub method descriptor and lookup function for nonoverridden
+        // methods so that resilient code sequences can still use them.
+        emitNonoverriddenMethod(fn);
+      }
     }
 
     void addMethodOverride(SILDeclRef baseRef, SILDeclRef declRef) {
@@ -1521,9 +1527,6 @@ namespace {
     }
 
     void addVTable() {
-      if (VTableEntries.empty())
-        return;
-      
       LLVM_DEBUG(
         llvm::dbgs() << "VTable entries for " << getType()->getName() << ":\n";
         for (auto entry : VTableEntries) {
@@ -1533,6 +1536,9 @@ namespace {
         }
       );
 
+      if (VTableEntries.empty())
+        return;
+      
       // Only emit a method lookup function if the class is resilient
       // and has a non-empty vtable.
       if (IGM.hasResilientMetadata(getType(), ResilienceExpansion::Minimal))
@@ -1595,8 +1601,25 @@ namespace {
         IGM.emitDispatchThunk(fn);
       }
     }
+    
+    void emitNonoverriddenMethod(SILDeclRef fn) {
+      // TODO: Emit a freestanding method descriptor structure, and a method
+      // lookup function, to present the ABI of an overridable method even
+      // though the method has no real overrides currently.
+    }
 
     void addOverrideTable() {
+      LLVM_DEBUG(
+        llvm::dbgs() << "Override Table entries for " << getType()->getName() << ":\n";
+        for (auto entry : OverrideTableEntries) {
+          llvm::dbgs() << "  ";
+          entry.first.print(llvm::dbgs());
+          llvm::dbgs() << " -> ";
+          entry.second.print(llvm::dbgs());
+          llvm::dbgs() << '\n';
+        }
+      );
+
       if (OverrideTableEntries.empty())
         return;
 
@@ -2702,12 +2725,12 @@ namespace {
     using super::asImpl;
     using super::IGM;
     using super::Target;
+    using super::VTable;
 
     ConstantStructBuilder &B;
 
     const ClassLayout &FieldLayout;
     const ClassMetadataLayout &MetadataLayout;
-    const SILVTable *VTable;
 
     Size AddressPoint;
 
@@ -2717,8 +2740,7 @@ namespace {
                              const ClassLayout &fieldLayout)
       : super(IGM, theClass), B(builder),
         FieldLayout(fieldLayout),
-        MetadataLayout(IGM.getClassMetadataLayout(theClass)),
-        VTable(IGM.getSILModule().lookUpVTable(theClass)) {}
+        MetadataLayout(IGM.getClassMetadataLayout(theClass)) {}
 
   public:
     SILType getLoweredType() {
@@ -2854,7 +2876,7 @@ namespace {
                            PointerAuthEntity::Special::HeapDestructor);
       } else {
         // In case the optimizer removed the function. See comment in
-        // addMethod().
+        // addReifiedVTableEntry().
         B.addNullPointer(IGM.FunctionPtrTy);
       }
     }
@@ -2973,7 +2995,7 @@ namespace {
       B.add(data);
     }
 
-    void addMethod(SILDeclRef fn) {
+    void addReifiedVTableEntry(SILDeclRef fn) {
       // Find the vtable entry.
       assert(VTable && "no vtable?!");
       auto entry = VTable->getEntry(IGM.getSILModule(), fn);
@@ -5086,3 +5108,33 @@ void IRGenModule::emitOpaqueTypeDecl(OpaqueTypeDecl *D) {
   // Emit the opaque type descriptor.
   OpaqueTypeDescriptorBuilder(*this, D).emit();
 }
+
+bool irgen::methodRequiresReifiedVTableEntry(IRGenModule &IGM,
+                                             const SILVTable *vtable,
+                                             SILDeclRef method) {
+  auto &M = IGM.getSILModule();
+  auto entry = vtable->getEntry(IGM.getSILModule(), method);
+  if (!entry) {
+    return true;
+  }
+  
+  // We may be able to elide the vtable entry, ABI permitting, if it's not
+  // overridden.
+  if (!entry->isNonOverridden()) {
+    return true;
+  }
+  
+  // Does the ABI require a vtable entry to exist? If the class is public,
+  // and it's either marked fragile or part of a non-resilient module, then
+  // other modules will directly address vtable offsets and we can't remove
+  // vtable entries.
+  if (vtable->getClass()->getEffectiveAccess() >= AccessLevel::Public) {
+    // TODO: Check whether we use a resilient ABI to access this
+    // class's methods. We can drop unnecessary vtable entries if we do;
+    // otherwise fixed vtable offsets are part of the ABI.
+    return true;
+  }
+    
+  // Otherwise, we can leave this method out of the runtime vtable.
+  return false;
+}

lib/IRGen/MetadataLayout.cpp

@@ -330,12 +330,12 @@ ClassMetadataLayout::ClassMetadataLayout(IRGenModule &IGM, ClassDecl *decl)
       super::addGenericArgument(requirement, forClass);
     }
 
-    void addMethod(SILDeclRef fn) {
+    void addReifiedVTableEntry(SILDeclRef fn) {
       if (fn.getDecl()->getDeclContext() == Target) {
         ++Layout.NumImmediateMembers;
         Layout.MethodInfos.try_emplace(fn, getNextOffset());
       }
-      super::addMethod(fn);
+      super::addReifiedVTableEntry(fn);
     }
 
     void noteStartOfFieldOffsets(ClassDecl *forClass) {

lib/SIL/IR/SILModule.cpp

@@ -476,7 +476,8 @@ void SILModule::eraseGlobalVariable(SILGlobalVariable *G) {
   getSILGlobalList().erase(G);
 }
 
-SILVTable *SILModule::lookUpVTable(const ClassDecl *C) {
+SILVTable *SILModule::lookUpVTable(const ClassDecl *C,
+                                   bool deserializeLazily) {
   if (!C)
     return nullptr;
 
@@ -485,6 +486,9 @@ SILVTable *SILModule::lookUpVTable(const ClassDecl *C) {
   if (R != VTableMap.end())
     return R->second;
 
+  if (!deserializeLazily)
+    return nullptr;
+
   // If that fails, try to deserialize it. If that fails, return nullptr.
   SILVTable *Vtbl = getSILLoader()->lookupVTable(C);
   if (!Vtbl)

lib/SIL/IR/SILPrinter.cpp

@@ -3131,16 +3131,17 @@ void SILVTable::print(llvm::raw_ostream &OS, bool Verbose) const {
     switch (entry.getKind()) {
     case SILVTable::Entry::Kind::Normal:
       break;
-    case SILVTable::Entry::Kind::NormalNonOverridden:
-      OS << " [nonoverridden]";
-      break;
     case SILVTable::Entry::Kind::Inherited:
       OS << " [inherited]";
       break;
     case SILVTable::Entry::Kind::Override:
       OS << " [override]";
       break;
     }
+    if (entry.isNonOverridden()) {
+      OS << " [nonoverridden]";
+    }
+
     OS << "\t// " << demangleSymbol(entry.getImplementation()->getName());
     OS << "\n";
   }