Fixed: Identify for ld64 linker for not emitting start group

Author: MrcSnm

source/redub/buildapi.d

@@ -8,7 +8,7 @@ import redub.package_searching.api;
 
 
 ///vX.X.X
-enum RedubVersionOnly = "v1.21.6";
+enum RedubVersionOnly = "v1.21.7";
 ///Redub vX.X.X
 enum RedubVersionShort = "Redub "~RedubVersionOnly;
 ///Redub vX.X.X - Description

source/redub/command_generators/linkers.d

@@ -10,7 +10,8 @@ string[] parseLinkConfiguration(const ThreadBuildData data, CompilingSession s,
     import redub.misc.path;
     import redub.building.cache;
     string[] commands;
-    bool isUsingGNULinker = s.compiler.usesGnuLinker;
+    AcceptedLinker linker = s.compiler.linker;
+    bool emitStartGroup = s.isa != ISA.webAssembly && linker != AcceptedLinker.ld64;
 
 
     const BuildConfiguration b = data.cfg;
@@ -41,14 +42,14 @@ string[] parseLinkConfiguration(const ThreadBuildData data, CompilingSession s,
         if (targetType.isLinkedSeparately)
         {
             //Only linux supports start/end group and no-as-needed. OSX does not
-            if(s.isa != ISA.webAssembly)
+            if(emitStartGroup)
             {
                 commands~= "-L--no-as-needed";
                 commands~= "-L--start-group";
             }
             ///Use library full path for the base file
             commands = mapAppendReverse(commands, data.extra.librariesFullPath, (string l) => "-L"~getOutputName(TargetType.staticLibrary, l, s.os));
-            if(s.isa != ISA.webAssembly)
+            if(emitStartGroup)
                 commands~= "-L--end-group";
             commands = mapAppendPrefix(commands, linkFlags, "-L", false);
             commands = mapAppendPrefix(commands, libraryPaths, "-L-L", true);

source/redub/compiler_identification.d

@@ -12,6 +12,14 @@ enum AcceptedCompiler
     gxx
 }
 
+enum AcceptedLinker
+{
+    unknown,
+    gnuld,
+    ld64,
+    ///I know there a plenty more, but still..
+}
+
 enum UsesGnuLinker
 {
     unknown,
@@ -32,6 +40,20 @@ AcceptedCompiler acceptedCompilerfromString(string str)
             throw new Exception("Invalid AcceptedCompiler string received: "~str);
     }
 }
+AcceptedLinker acceptedLinkerfromString(string str)
+{
+    switch(str)
+    {
+        static foreach(mem; __traits(allMembers, AcceptedLinker))
+        {
+            case mem:
+                return __traits(getMember, AcceptedLinker, mem);
+        }
+        default:
+            return AcceptedLinker.unknown;
+    }
+}
+
 
 
 /** 
@@ -60,7 +82,7 @@ struct Compiler
 
     ///Currently unused. Was used before for checking whether --start-group should be emitted or not. Since it is emitted
     ///by default, only on webAssembly which is not, it lost its usage for now.
-    bool usesGnuLinker = false;
+    AcceptedLinker linker = AcceptedLinker.unknown;
 
 
     string getCompilerString() const
@@ -217,7 +239,7 @@ Compiler getCompiler(string compilerOrPath = "dmd", string compilerAssumption =
     if(ret == Compiler.init)
         ret = inferCompiler(compilerOrPath, compilerAssumption, compilersInfo, isDefault, isGlobal);
 
-    ret.usesGnuLinker = compilersInfo["defaultsToGnuLd"].boolean;
+    ret.linker = acceptedLinkerfromString(compilersInfo["defaultLinker"].str);
 
     //Checks for ldc.conf switches to see if it is using gnu linker by default
     ///TODO: Might be reactivated if that issue shows again.
@@ -354,7 +376,7 @@ private Compiler getCompilerFromCache(JSONValue allCompilersInfo, string compile
                     SemVer(arr[VERSION_].str),
                     SemVer(arr[FRONTEND_VERSION].str),
                     arr[VERSION_STRING].str,
-                    key, null, false, allCompilersInfo["defaultsToGnuLd"].boolean
+                    key, null, false, acceptedLinkerfromString(allCompilersInfo["defaultLinker"].str)
                 );
             }
         }
@@ -396,10 +418,10 @@ private void saveCompilerInfo(JSONValue allCompilersInfo, ref Compiler compiler,
     if(!("version" in allCompilersInfo))
         allCompilersInfo["version"] = JSONValue(RedubVersionOnly);
 
-    if(!("defaultsToGnuLd" in allCompilersInfo))
-        allCompilersInfo["defaultsToGnuLd"] = JSONValue(isDefaultLinkerGnuLd());
+    if(!("defaultLinker" in allCompilersInfo))
+        allCompilersInfo["defaultLinker"] = JSONValue(getDefaultLinker().to!string);
 
-    compiler.usesGnuLinker = allCompilersInfo["defaultsToGnuLd"].boolean;
+    compiler.linker = acceptedLinkerfromString(allCompilersInfo["defaultLinker"].str);
 
     if(!("compilers" in allCompilersInfo))
         allCompilersInfo["compilers"] = JSONValue.emptyObject;
@@ -453,17 +475,23 @@ private Compiler assumeCompiler(string compilerOrPath, string compilerAssumption
 }
 
 
-bool isDefaultLinkerGnuLd()
+AcceptedLinker getDefaultLinker()
 {
-    version(linux)
+    version(Posix)
     {
         import std.process;
         import std.string;
         auto res = executeShell("ld -v");
-        return res.status == 0 && res.output.startsWith("GNU ld");
+        if(res.status == 0)
+            return AcceptedLinker.unknown;
+
+        if(res.output.startsWith("GNU ld"))
+            return AcceptedLinker.gnuld;
+        else if(res.output.startsWith("@(#)PROGRAM:ld"))
+            return AcceptedLinker.ld64;
     }
-    else
-        return false;
+
+    return AcceptedLinker.unknown;
 }
 
 private bool tryInferLdc(string compilerOrPath, string vString, out Compiler comp)