Implement -extI and -dllimport=externalOnly

Author: kinke

dmd/globals.d

@@ -119,7 +119,8 @@ enum LinkonceTemplates : byte
 enum DLLImport : byte
 {
     none,
-    defaultLibsOnly, // only symbols from druntime/Phobos
+    externalOnly,    // only symbols from -extI modules
+    defaultLibsOnly, // only symbols from druntime/Phobos and -extI modules
     all
 }
 } // IN_LLVM

dmd/globals.h

@@ -127,7 +127,8 @@ enum class LinkonceTemplates : char
 enum class DLLImport : char
 {
     none,
-    defaultLibsOnly, // only symbols from druntime/Phobos
+    externalOnly,    // only symbols from -extI modules
+    defaultLibsOnly, // only symbols from druntime/Phobos and -extI modules
     all
 };
 #endif

driver/cl_helpers.cpp

@@ -72,7 +72,7 @@ void ImportPathsAdapter::push_back(const char *cstr) {
     error(Loc(), "Expected argument to '-%s'", name);
   }
 
-  arrp->push(ImportPathInfo(mem.xstrdup(cstr)));
+  arrp->push(ImportPathInfo(mem.xstrdup(cstr), isExternal));
 }
 
 } // namespace opts

driver/cl_helpers.h

@@ -183,11 +183,13 @@ class StringsAdapter {
 class ImportPathsAdapter {
   const char *name;
   Array<ImportPathInfo> *arrp;
+  bool isExternal;
 
 public:
-  ImportPathsAdapter(const char *name_, Array<ImportPathInfo> &arr) {
+  ImportPathsAdapter(const char *name_, Array<ImportPathInfo> &arr, bool isExternal_) {
     name = name_;
     arrp = &arr;
+    isExternal = isExternal_;
     assert(name);
   }
 

driver/cl_options.cpp

@@ -77,9 +77,13 @@ cl::opt<DLLImport, true> dllimport(
     cl::values(
         clEnumValN(DLLImport::none, "none",
                    "None (default with -link-defaultlib-shared=false)"),
+        clEnumValN(
+            DLLImport::externalOnly, "externalOnly",
+            "Only symbols from modules imported from an -extI import root"),
         clEnumValN(DLLImport::defaultLibsOnly, "defaultLibsOnly",
-                   "Only druntime/Phobos symbols (default with "
-                   "-link-defaultlib-shared and -fvisibility=hidden)."),
+                   "Only druntime/Phobos symbols and symbols from modules "
+                   "imported from an -extI import root (default with "
+                   "-link-defaultlib-shared and -fvisibility=hidden)"),
         clEnumValN(DLLImport::all, "all",
                    "All (default with -link-defaultlib-shared and "
                    "-fvisibility=public)")));

driver/ldmd.cpp

@@ -174,7 +174,7 @@ Where:\n\
   -deps             print module dependencies (imports/file/version/debug/lib)\n\
   -deps=<filename>  write module dependencies to filename (only imports)\n\
   -dllimport=<value>\n\
-                    Windows only: select symbols to dllimport (none/defaultLibsOnly/all)\n\
+                    Windows only: select symbols to dllimport (none/defaultLibsOnly/externalOnly/all)\n\
   -extern-std=<standard>\n\
                     set C++ name mangling compatibility with <standard>\n"
 #if 0
@@ -210,6 +210,7 @@ Where:\n\
   -HCf=<filename>   write C++ 'header' file to filename instead of stdout\n\
   --help            print help and exit\n\
   -I=<directory>    look for imports also in directory\n\
+  -extI=<directory> look for imports that are out of the currently compiling binary, used to set the module as DllImport\n\
   -i[=<pattern>]    include imported modules in the compilation\n\
   -identifiers=<table>\n\
                     specify the non-ASCII tables for D identifiers\n\
@@ -689,6 +690,7 @@ void translateArgs(const llvm::SmallVectorImpl<const char *> &ldmdArgs,
       }
       /* -unittest
        * -I
+       * -extI
        * -J
        */
       else if (startsWith(p + 1, "debug") && p[6] != 'l') {

driver/main.cpp

@@ -90,12 +90,22 @@ void generateJson(Modules *modules);
 using namespace dmd;
 using namespace opts;
 
-static ImportPathsAdapter impPathsStore("I", global.params.imppath);
+static ImportPathsAdapter impPathsStore("I", global.params.imppath,
+                                        /*isExternal=*/false);
 static cl::list<std::string, ImportPathsAdapter>
     importPaths("I", cl::desc("Look for imports also in <directory>"),
                 cl::value_desc("directory"), cl::location(impPathsStore),
                 cl::Prefix);
 
+static ImportPathsAdapter extImpPathsStore("extI", global.params.imppath,
+                                           /*isExternal=*/true);
+static cl::list<std::string, ImportPathsAdapter> extImportPaths(
+    "extI",
+    cl::desc("Look also in <directory> for imports that are external to the "
+             "currently compiling binary. This affects the -dllimport behavior "
+             "for data symbols from these binary-external modules."),
+    cl::value_desc("directory"), cl::location(extImpPathsStore));
+
 // Note: this option is parsed manually in C main().
 static cl::opt<bool> enableGC(
     "lowmem", cl::ZeroOrMore,

gen/llvmhelpers.cpp

@@ -1676,25 +1676,35 @@ static bool isDefaultLibSymbol(Dsymbol *sym) {
             (md->packages.length > 1 && md->packages.ptr[1] == Id::io)));
 }
 
+static bool isExplicitlyOutOfBinary(Dsymbol *sym) {
+  if (auto mod = sym->getModule())
+    return mod->isExplicitlyOutOfBinary;
+  return false;
+}
+
 bool defineOnDeclare(Dsymbol *sym, bool isFunction) {
   // -linkonce-templates: all instantiated symbols
   if (global.params.linkonceTemplates != LinkonceTemplates::no)
     return sym->isInstantiated();
 
-  // -dllimport=defaultLibsOnly: all data symbols instantiated from
-  // druntime/Phobos templates
+  // -dllimport=externalOnly|defaultLibsOnly: all data symbols instantiated from
+  // binary-external modules, e.g., druntime/Phobos templates
   // see https://github.com/ldc-developers/ldc/issues/3931
-  return !isFunction && global.params.dllimport == DLLImport::defaultLibsOnly &&
-         sym->isInstantiated() && isDefaultLibSymbol(sym);
+  const auto di = global.params.dllimport;
+  return !isFunction && sym->isInstantiated() &&
+         ((di == DLLImport::externalOnly && isExplicitlyOutOfBinary(sym)) ||
+          (di == DLLImport::defaultLibsOnly &&
+           (isExplicitlyOutOfBinary(sym) || isDefaultLibSymbol(sym))));
 }
 
 bool dllimportDataSymbol(Dsymbol *sym) {
   if (!global.params.targetTriple->isOSWindows())
     return false;
 
-  if (sym->isExport() || global.params.dllimport == DLLImport::all ||
-      (global.params.dllimport == DLLImport::defaultLibsOnly &&
-       isDefaultLibSymbol(sym))) {
+  const auto di = global.params.dllimport;
+  if (sym->isExport() || di == DLLImport::all ||
+      (di >= DLLImport::externalOnly && isExplicitlyOutOfBinary(sym)) ||
+      (di == DLLImport::defaultLibsOnly && isDefaultLibSymbol(sym))) {
     // Okay, this symbol is a candidate. Use dllimport unless we have a
     // guaranteed-codegen'd definition in a root module.
     if (auto mod = sym->isModule())

gen/modules.cpp

@@ -150,9 +150,8 @@ LLFunction *build_module_reference_and_ctor(const char *moduleMangle,
   LLConstant *mref = gIR->module.getNamedGlobal(mrefIRMangle);
   LLType *ptrTy = getOpaquePtrType();
   if (!mref) {
-    mref =
-        declareGlobal(Loc(), gIR->module, ptrTy, mrefIRMangle, false,
-                      false, global.params.dllimport != DLLImport::none);
+    mref = declareGlobal(Loc(), gIR->module, ptrTy, mrefIRMangle, false, false,
+                         false);
   }
 
   // make the function insert this moduleinfo as the beginning of the

gen/typinf.cpp

@@ -450,7 +450,8 @@ void buildTypeInfo(TypeInfoDeclaration *decl) {
     // immutable on the D side, and e.g. synchronized() can be used on the
     // implicit monitor.
     const bool isConstant = false;
-    bool useDLLImport = isBuiltin && global.params.dllimport != DLLImport::none;
+    const bool useDLLImport =
+        isBuiltin && global.params.dllimport >= DLLImport::defaultLibsOnly;
     gvar = declareGlobal(decl->loc, gIR->module, type, irMangle, isConstant,
                          false, useDLLImport);
   }