Merge pull request #61886 from tshortli/silgen-has-symbol-forward-decls

SILGen: Forward declare SIL functions referenced by `#_hasSymbol` query helpers

Author: tshortli

include/swift/IRGen/IRSymbolVisitor.h

@@ -58,7 +58,8 @@ class IRSymbolVisitor {
                     const IRSymbolVisitorContext &ctx);
 
   /// Override to prepare for enumeration of the symbols for a specific decl.
-  virtual void willVisitDecl(Decl *D) {}
+  /// Return \c true to proceed with visiting the decl or \c false to skip it.
+  virtual bool willVisitDecl(Decl *D) { return true; }
 
   /// Override to clean up after enumeration of the symbols for a specific decl.
   virtual void didVisitDecl(Decl *D) {}

include/swift/SIL/SILLinkage.h

@@ -74,7 +74,7 @@ enum class SILLinkage : uint8_t {
   ///
   /// This linkage is used e.g. for thunks and for specialized functions.
   ///
-  /// Public functions must be definitions, i.e. must have a body, except the
+  /// Shared functions must be definitions, i.e. must have a body, except the
   /// body is emitted by clang.
   Shared,
 

include/swift/SIL/SILModule.h

@@ -279,7 +279,7 @@ class SILModule {
   llvm::DenseMap<const NominalTypeDecl *, SILMoveOnlyDeinit *>
       MoveOnlyDeinitMap;
 
-  /// The list of SILVTables in the module.
+  /// The list of move only deinits in the module.
   std::vector<SILMoveOnlyDeinit *> moveOnlyDeinits;
 
   /// Declarations which are externally visible.
@@ -315,6 +315,9 @@ class SILModule {
   /// This is the set of undef values we've created, for uniquing purposes.
   llvm::DenseMap<SILType, SILUndef *> UndefValues;
 
+  /// The list of decls that require query functions for #_hasSymbol conditions.
+  llvm::SetVector<ValueDecl *> hasSymbolDecls;
+
   llvm::DenseMap<std::pair<Decl *, VarDecl *>, unsigned> fieldIndices;
   llvm::DenseMap<EnumElementDecl *, unsigned> enumCaseIndices;
 
@@ -700,6 +703,12 @@ class SILModule {
     return externallyVisible.count(decl) != 0;
   }
 
+  void addHasSymbolDecl(ValueDecl *decl) { hasSymbolDecls.insert(decl); }
+
+  ArrayRef<ValueDecl *> getHasSymbolDecls() {
+    return hasSymbolDecls.getArrayRef();
+  }
+
   using sil_global_iterator = GlobalListType::iterator;
   using sil_global_const_iterator = GlobalListType::const_iterator;
   GlobalListType &getSILGlobalList() { return silGlobals; }

include/swift/SIL/SILSymbolVisitor.h

@@ -76,7 +76,8 @@ class SILSymbolVisitor {
                     const SILSymbolVisitorContext &ctx);
 
   /// Override to prepare for enumeration of the symbols for a specific decl.
-  virtual void willVisitDecl(Decl *D) {}
+  /// Return \c true to proceed with visiting the decl or \c false to skip it.
+  virtual bool willVisitDecl(Decl *D) { return true; }
 
   /// Override to clean up after enumeration of the symbols for a specific decl.
   virtual void didVisitDecl(Decl *D) {}

lib/IRGen/IRGenModule.cpp

@@ -85,13 +85,6 @@ static llvm::StructType *createStructType(IRGenModule &IGM,
                                   name, packed);
 }
 
-/// A helper for creating pointer-to-struct types.
-static llvm::PointerType *createStructPointerType(IRGenModule &IGM,
-                                                  StringRef name,
-                                  std::initializer_list<llvm::Type*> types) {
-  return createStructType(IGM, name, types)->getPointerTo(DefaultAS);
-}
-
 static clang::CodeGenerator *createClangCodeGenerator(ASTContext &Context,
                                                  llvm::LLVMContext &LLVMContext,
                                                       const IRGenOptions &Opts,

lib/IRGen/IRSymbolVisitor.cpp

@@ -72,8 +72,8 @@ class IRSymbolVisitorImpl : public SILSymbolVisitor {
       : Visitor{Visitor}, Ctx{Ctx},
         PublicSymbolsOnly{Ctx.getSILCtx().getOpts().PublicSymbolsOnly} {}
 
-  void willVisitDecl(Decl *D) override {
-    Visitor.willVisitDecl(D);
+  bool willVisitDecl(Decl *D) override {
+    return Visitor.willVisitDecl(D);
   }
 
   void didVisitDecl(Decl *D) override {

lib/IRGen/TBDGen.cpp

@@ -400,8 +400,15 @@ void TBDGenVisitor::addSymbol(StringRef name, SymbolSource source,
   }
 }
 
-void TBDGenVisitor::willVisitDecl(Decl *D) {
+bool TBDGenVisitor::willVisitDecl(Decl *D) {
+  // A @_silgen_name("...") function without a body only exists to
+  // forward-declare a symbol from another library.
+  if (auto AFD = dyn_cast<AbstractFunctionDecl>(D))
+    if (!AFD->hasBody() && AFD->getAttrs().hasAttribute<SILGenNameAttr>())
+      return false;
+
   DeclStack.push_back(D);
+  return true;
 }
 
 void TBDGenVisitor::didVisitDecl(Decl *D) {

lib/IRGen/TBDGenVisitor.h

@@ -139,7 +139,7 @@ class TBDGenVisitor : public IRSymbolVisitor {
 
   // --- IRSymbolVisitor ---
 
-  void willVisitDecl(Decl *D) override;
+  bool willVisitDecl(Decl *D) override;
   void didVisitDecl(Decl *D) override;
 
   void addFunction(SILDeclRef declRef) override;

lib/SIL/IR/SILSymbolVisitor.cpp

@@ -362,7 +362,8 @@ class SILSymbolVisitorImpl : public ASTVisitor<SILSymbolVisitorImpl> {
       : Visitor{Visitor}, Ctx{Ctx} {}
 
   void visit(Decl *D) {
-    Visitor.willVisitDecl(D);
+    if (!Visitor.willVisitDecl(D))
+      return;
     ASTVisitor::visit(D);
     Visitor.didVisitDecl(D);
   }
@@ -408,12 +409,6 @@ class SILSymbolVisitorImpl : public ASTVisitor<SILSymbolVisitorImpl> {
   }
 
   void visitAbstractFunctionDecl(AbstractFunctionDecl *AFD) {
-    // A @_silgen_name("...") function without a body only exists to
-    // forward-declare a symbol from another library.
-    if (!AFD->hasBody() && AFD->getAttrs().hasAttribute<SILGenNameAttr>()) {
-      return;
-    }
-
     // Add exported prespecialized symbols.
     for (auto *attr : AFD->getAttrs().getAttributes<SpecializeAttr>()) {
       if (!attr->isExported())

lib/SILGen/SILGenDecl.cpp

@@ -30,6 +30,7 @@
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILDebuggerClient.h"
 #include "swift/SIL/SILInstruction.h"
+#include "swift/SIL/SILSymbolVisitor.h"
 #include "swift/SIL/SILType.h"
 #include "swift/SIL/TypeLowering.h"
 #include "llvm/ADT/SmallString.h"
@@ -1601,21 +1602,57 @@ void SILGenFunction::emitStmtCondition(StmtCondition Cond, JumpDest FalseDest,
 
     case StmtConditionElement::CK_HasSymbol: {
       auto info = elt.getHasSymbolInfo();
-      assert(!info->isInvalid());
+      if (info->isInvalid()) {
+        // This condition may have referenced a decl that isn't valid in some
+        // way but for developer convenience wasn't treated as an error. Just
+        // emit a 'true' condition value.
+        SILType i1 = SILType::getBuiltinIntegerType(1, getASTContext());
+        booleanTestValue = B.createIntegerLiteral(loc, i1, 1);
+        break;
+      }
+
       auto expr = info->getSymbolExpr();
       auto declRef = info->getReferencedDecl();
       assert(declRef);
 
-      auto queryFunc = declRef.getDecl()->getHasSymbolQueryDecl();
+      auto decl = declRef.getDecl();
+      getModule().addHasSymbolDecl(decl);
+
       SILFunction *silFn = SGM.getFunction(
-          SILDeclRef(queryFunc, SILDeclRef::Kind::Func), NotForDefinition);
+          SILDeclRef(decl->getHasSymbolQueryDecl(), SILDeclRef::Kind::Func),
+          NotForDefinition);
       SILValue fnRef = B.createFunctionRefFor(loc, silFn);
       booleanTestValue = B.createApply(loc, fnRef, {}, {});
       booleanTestValue = emitUnwrapIntegerResult(expr, booleanTestValue);
       booleanTestLoc = expr;
 
-      // FIXME: Add decl to list of decls that need a has symbol query
-      //        function to be emitted during IRGen.
+      // Ensure that function declarations for each function associated with
+      // the decl are emitted so that they can be referenced during IRGen.
+      class SymbolVisitor : public SILSymbolVisitor {
+        SILGenModule &SGM;
+
+      public:
+        SymbolVisitor(SILGenModule &SGM) : SGM{SGM} {};
+
+        void addFunction(SILDeclRef declRef) override {
+          (void)SGM.getFunction(declRef, NotForDefinition);
+        }
+
+        virtual void addFunction(StringRef name, SILDeclRef declRef) override {
+          // The kinds of functions which go through this callback (e.g.
+          // differentiability witnesses) can't be forward declared with a
+          // SILDeclRef alone. For now, just ignore them.
+          //
+          // Ideally, this callback will be removed entirely in favor of
+          // SILDeclRef being able to represent all function variants.
+        }
+      };
+
+      SILSymbolVisitorOptions opts;
+      opts.VisitMembers = false;
+      auto visitorCtx =
+          SILSymbolVisitorContext(getModule().getSwiftModule(), opts);
+      SymbolVisitor(SGM).visitDecl(decl, visitorCtx);
       break;
     }
     }