Improve Objective-C support

dmd/id.d

@@ -626,6 +626,7 @@ immutable Msgtable[] msgtable =
     { "udaHidden", "_hidden" },
     { "udaNoSanitize", "noSanitize" },
     { "udaNoSplitStack", "_noSplitStack" },
+    { "udaSwiftStub", "swift"},
 
     // IN_LLVM: DCompute specific types and functionss
     { "dcompute" },

dmd/objc.d

@@ -156,6 +156,9 @@ extern (C++) struct ObjcClassDeclaration
     /// `true` if this class is externally defined.
     bool isExtern = false;
 
+    /// `true` if this class is a Swift stub
+    version(IN_LLVM) bool isSwiftStub = false;
+
     /// Name of this class.
     Identifier identifier;
 
@@ -264,6 +267,16 @@ extern(C++) abstract class Objc
      */
     abstract void setAsOptional(FuncDeclaration functionDeclaration, Scope* sc) const;
 
+    /**
+     * Marks the given class as a Swift stub class.
+     *
+     * Params:
+     *  cd = the class declaration to set as a swift stub
+     *  sc = the scope from the semantic phase
+     */
+    version(IN_LLVM)
+    abstract void setAsSwiftStub(ClassDeclaration cd, Scope* sc) const;
+
     /**
      * Validates function declarations declared optional.
      *
@@ -452,6 +465,12 @@ static if (!IN_LLVM)
         // noop
     }
 
+    version(IN_LLVM)
+    override void setAsSwiftStub(ClassDeclaration, Scope*) const
+    {
+        // noop
+    }
+
     override void validateOptional(FuncDeclaration) const
     {
         // noop
@@ -532,6 +551,7 @@ version (IN_LLVM) {} else
     {
         cd.classKind = ClassKind.objc;
         cd.objc.isExtern = (cd.storage_class & STC.extern_) > 0;
+        this.setAsSwiftStub(cd, cd._scope);
     }
 
     override void setObjc(InterfaceDeclaration id)
@@ -826,6 +846,42 @@ version (IN_LLVM) {} else
         errorSupplemental(expression.loc, "`tupleof` is not available for members " ~
             "of Objective-C classes. Please use the Objective-C runtime instead");
     }
+
+    version(IN_LLVM) {
+        override void setAsSwiftStub(ClassDeclaration cd, Scope* sc) const
+        {
+            const count = declaredAsSwiftStubCount(cd, sc);
+            cd.objc.isSwiftStub = count > 0;
+
+            if (count > 1)
+                .error(cd.loc, "%s `%s` can only declare a class as a swift stub once", cd.kind, cd.toPrettyChars);
+        }
+
+        /// Returns: the number of times `cd` has been declared as optional.
+        private int declaredAsSwiftStubCount(ClassDeclaration cd, Scope* sc) const
+        {
+            int count;
+
+            foreachUda(cd, sc, (e) {
+                if (!e.isTypeExp())
+                    return 0;
+
+                auto typeExp = e.isTypeExp();
+
+                if (typeExp.type.ty != Tenum)
+                    return 0;
+
+                auto typeEnum = cast(TypeEnum) typeExp.type;
+
+                if (isCoreUda(typeEnum.sym, Id.udaSwiftStub))
+                    count++;
+
+                return 0;
+            });
+
+            return count;
+        }
+    }
 }
 
 /*

dmd/objc.h

@@ -37,6 +37,9 @@ struct ObjcClassDeclaration
 {
     d_bool isMeta;
     d_bool isExtern;
+#if IN_LLVM
+    d_bool isSwiftStub;
+#endif
 
     Identifier* identifier;
     ClassDeclaration* classDeclaration;
@@ -67,6 +70,9 @@ class Objc
     virtual void checkLinkage(FuncDeclaration* fd) = 0;
     virtual bool isVirtual(const FuncDeclaration*) const = 0;
     virtual void setAsOptional(FuncDeclaration *fd, Scope *sc) const = 0;
+#if IN_LLVM
+    virtual void setAsSwiftStub(ClassDeclaration* cd, Scope *sc) const = 0;
+#endif
     virtual void validateOptional(FuncDeclaration *fd) const = 0;
     virtual ClassDeclaration* getParent(FuncDeclaration*, ClassDeclaration*) const = 0;
     virtual void addToClassMethodList(FuncDeclaration*, ClassDeclaration*) const = 0;

driver/linker-gcc.cpp

@@ -48,6 +48,10 @@ static llvm::cl::opt<bool> linkNoCpp(
     "link-no-cpp", llvm::cl::ZeroOrMore, llvm::cl::Hidden,
     llvm::cl::desc("Disable automatic linking with the C++ standard library."));
 
+static llvm::cl::opt<bool> linkNoObjc(
+    "link-no-objc", llvm::cl::ZeroOrMore, llvm::cl::Hidden,
+    llvm::cl::desc("Disable automatic linking with the Objective-C runtime library."));
+
 //////////////////////////////////////////////////////////////////////////////
 
 namespace {
@@ -72,6 +76,7 @@ class ArgsBuilder {
   virtual void addXRayLinkFlags(const llvm::Triple &triple);
   virtual bool addCompilerRTArchiveLinkFlags(llvm::StringRef baseName,
                                              const llvm::Triple &triple);
+  virtual void addObjcStdlibLinkFlags(const llvm::Triple &triple);
 
   virtual void addLinker();
   virtual void addUserSwitches();
@@ -467,6 +472,13 @@ void ArgsBuilder::addCppStdlibLinkFlags(const llvm::Triple &triple) {
   }
 }
 
+void ArgsBuilder::addObjcStdlibLinkFlags(const llvm::Triple &triple) {
+  if (linkNoObjc)
+    return;
+
+  args.push_back("-lobjc");
+}
+
 // Adds all required link flags for PGO.
 void ArgsBuilder::addProfileRuntimeLinkFlags(const llvm::Triple &triple) {
   const auto searchPaths =
@@ -725,6 +737,13 @@ void ArgsBuilder::addDefaultPlatformLibs() {
     break;
   }
 
+  if (triple.isOSDarwin()) {
+
+    // libobjc is more or less required, so we link against it here.
+    // This could be prettier, though.
+    addObjcStdlibLinkFlags(triple);
+  }
+
   if (triple.isWindowsGNUEnvironment()) {
     // This is really more of a kludge, as linking in the Winsock functions
     // should be handled by the pragma(lib, ...) in std.socket, but it

gen/abi/aarch64.cpp

@@ -29,12 +29,11 @@ using namespace dmd;
  */
 struct AArch64TargetABI : TargetABI {
 private:
-  const bool isDarwin;
   IndirectByvalRewrite indirectByvalRewrite;
   ArgTypesRewrite argTypesRewrite;
 
   bool isAAPCS64VaList(Type *t) {
-    if (isDarwin)
+    if (isDarwin())
       return false;
 
     // look for a __va_list struct in a `std` C++ namespace
@@ -51,7 +50,7 @@ struct AArch64TargetABI : TargetABI {
   }
 
 public:
-  AArch64TargetABI() : isDarwin(global.params.targetTriple->isOSDarwin()) {}
+  AArch64TargetABI() {}
 
   bool returnInArg(TypeFunction *tf, bool) override {
     if (tf->isref()) {
@@ -108,7 +107,7 @@ struct AArch64TargetABI : TargetABI {
         }
 
         // https://developer.apple.com/library/archive/documentation/Xcode/Conceptual/iPhoneOSABIReference/Articles/ARM64FunctionCallingConventions.html#//apple_ref/doc/uid/TP40013702-SW1
-        if (isDarwin) {
+        if (isDarwin()) {
           if (auto ts = tb->isTypeStruct()) {
             if (ts->sym->fields.empty() && ts->sym->isPOD()) {
               fty.args.erase(fty.args.begin() + i);
@@ -166,7 +165,7 @@ struct AArch64TargetABI : TargetABI {
   }
 
   Type *vaListType() override {
-    if (isDarwin)
+    if (isDarwin())
       return TargetABI::vaListType(); // char*
 
     // We need to pass the actual va_list type for correct mangling. Simply
@@ -176,9 +175,11 @@ struct AArch64TargetABI : TargetABI {
     return TypeIdentifier::create(Loc(), Identifier::idPool("__va_list"));
   }
 
-  const char *objcMsgSendFunc(Type *ret, IrFuncTy &fty) override {
+  const char *objcMsgSendFunc(Type *ret, IrFuncTy &fty, bool directcall) override {
+    assert(isDarwin());
+
     // see objc/message.h for objc_msgSend selection rules
-    return "objc_msgSend";
+    return directcall ? "objc_msgSendSuper" : "objc_msgSend";
   }
 };
 

gen/abi/abi.cpp

@@ -207,7 +207,7 @@ Type *TargetABI::vaListType() {
 
 //////////////////////////////////////////////////////////////////////////////
 
-const char *TargetABI::objcMsgSendFunc(Type *ret, IrFuncTy &fty) {
+const char *TargetABI::objcMsgSendFunc(Type *ret, IrFuncTy &fty, bool directcall) {
   llvm_unreachable("Unknown Objective-C ABI");
 }
 

gen/abi/abi.h

@@ -70,6 +70,7 @@ struct ABIRewrite {
 
 // interface called by codegen
 struct TargetABI {
+public:
   virtual ~TargetABI() = default;
 
   /// Returns the ABI for the target we're compiling for
@@ -117,6 +118,11 @@ struct TargetABI {
            global.params.targetTriple->getOS() == llvm::Triple::NetBSD;
   }
 
+  /// Returns true if the target is darwin-based.
+  bool isDarwin() {
+    return global.params.targetTriple->isOSDarwin();
+  }
+
   /// Returns true if the D function uses sret (struct return).
   /// `needsThis` is true if the function type is for a non-static member
   /// function.
@@ -171,7 +177,7 @@ struct TargetABI {
   virtual Type *vaListType();
 
   /// Returns Objective-C message send function
-  virtual const char *objcMsgSendFunc(Type *ret, IrFuncTy &fty);
+  virtual const char *objcMsgSendFunc(Type *ret, IrFuncTy &fty, bool directcall);
 
   /***** Static Helpers *****/
 

gen/abi/arm.cpp

@@ -122,14 +122,6 @@ struct ArmTargetABI : TargetABI {
     // solution is found there, this should be adapted).
     return TypeIdentifier::create(Loc(), Identifier::idPool("__va_list"));
   }
-
-  const char *objcMsgSendFunc(Type *ret, IrFuncTy &fty) override {
-    // see objc/message.h for objc_msgSend selection rules
-    if (fty.arg_sret) {
-      return "objc_msgSend_stret";
-    }
-    return "objc_msgSend";
-  }
 };
 
 TargetABI *getArmTargetABI() { return new ArmTargetABI; }

gen/abi/x86-64.cpp

@@ -165,7 +165,7 @@ struct X86_64TargetABI : TargetABI {
 
   Type *vaListType() override;
 
-  const char *objcMsgSendFunc(Type *ret, IrFuncTy &fty) override;
+  const char *objcMsgSendFunc(Type *ret, IrFuncTy &fty, bool directcall) override;
 
 private:
   LLType *getValistType();
@@ -196,9 +196,6 @@ struct X86_64TargetABI : TargetABI {
   }
 };
 
-// The public getter for abi.cpp
-TargetABI *getX86_64TargetABI() { return new X86_64TargetABI; }
-
 bool X86_64TargetABI::returnInArg(TypeFunction *tf, bool) {
   if (tf->isref()) {
     return false;
@@ -382,21 +379,19 @@ Type *X86_64TargetABI::vaListType() {
       TypeIdentifier::create(Loc(), Identifier::idPool("__va_list_tag")));
 }
 
-const char *X86_64TargetABI::objcMsgSendFunc(Type *ret,
-                                             IrFuncTy &fty) {
+const char *X86_64TargetABI::objcMsgSendFunc(Type *ret, IrFuncTy &fty, bool directcall) {
+  assert(isDarwin());
+
   // see objc/message.h for objc_msgSend selection rules
   if (fty.arg_sret) {
-    return "objc_msgSend_stret";
+    return directcall ? "objc_msgSendSuper_stret" : "objc_msgSend_stret";
   }
-  if (ret) {
-    // complex long double return
-    if (ret->ty == TY::Tcomplex80) {
-      return "objc_msgSend_fp2ret";
-    }
-    // long double return
-    if (ret->ty == TY::Tfloat80 || ret->ty == TY::Timaginary80) {
-      return "objc_msgSend_fpret";
-    }
+  // float, double, long double return
+  if (ret && ret->isfloating()) {
+    return ret->ty == TY::Tcomplex80 ? "objc_msgSend_fp2ret" : "objc_msgSend_fpret";
   }
-  return "objc_msgSend";
+  return directcall ? "objc_msgSendSuper" : "objc_msgSend";
 }
+
+// The public getter for abi.cpp
+TargetABI *getX86_64TargetABI() { return new X86_64TargetABI; }

gen/abi/x86.cpp

@@ -23,15 +23,13 @@
 using namespace dmd;
 
 struct X86TargetABI : TargetABI {
-  const bool isDarwin;
   const bool isMSVC;
   bool returnStructsInRegs;
   IntegerRewrite integerRewrite;
   IndirectByvalRewrite indirectByvalRewrite;
 
   X86TargetABI()
-      : isDarwin(global.params.targetTriple->isOSDarwin()),
-        isMSVC(global.params.targetTriple->isWindowsMSVCEnvironment()) {
+      : isMSVC(global.params.targetTriple->isWindowsMSVCEnvironment()) {
     using llvm::Triple;
     auto os = global.params.targetTriple->getOS();
     returnStructsInRegs =
@@ -230,7 +228,7 @@ struct X86TargetABI : TargetABI {
     // Clang does not pass empty structs, while it seems that GCC does,
     // at least on Linux x86. We don't know whether the C compiler will
     // be Clang or GCC, so just assume Clang on Darwin and G++ on Linux.
-    if (externD || !isDarwin)
+    if (externD || !isDarwin())
       return;
 
     size_t i = 0;
@@ -272,19 +270,6 @@ struct X86TargetABI : TargetABI {
       }
     }
   }
-
-  const char *objcMsgSendFunc(Type *ret, IrFuncTy &fty) override {
-    // see objc/message.h for objc_msgSend selection rules
-    assert(isDarwin);
-    if (fty.arg_sret) {
-      return "objc_msgSend_stret";
-    }
-    // float, double, long double return
-    if (ret && ret->isfloating() && !ret->iscomplex()) {
-      return "objc_msgSend_fpret";
-    }
-    return "objc_msgSend";
-  }
 };
 
 // The public getter for abi.cpp.