Fixed: Archiver now putting object files correctly

MrcSnm · MrcSnm · commit b2fb685e11c9 · 2025-03-25T01:51:33.000-03:00
diff --git a/source/redub/building/compile.d b/source/redub/building/compile.d
@@ -126,13 +126,13 @@ CompilationResult execCompilation(immutable ThreadBuildData data, shared Project
             if(!pack.isCopyEnough)
                 ret = cast(ExecutionResult)execCompiler(cfg, compiler.binOrPath, getCompilationFlags(cfg, info, hash.rootHash, data.extra.isRoot), res.compilationCommand, compiler, inDir);
 
-            if(!isDCompiler(compiler) && !ret.status) //Always requires link.
+            if(!isDCompiler(compiler) && !ret.status && isStaticLibrary(data.cfg.targetType)) //Must call archiver when
             {
                 string cmd ;
                 auto archiverRes = executeArchiver(data, info, cmd);
                 ret.status = archiverRes.status;
                 ret.output~= archiverRes.output;
-                res.compilationCommand~= cmd;
+                res.compilationCommand~= "\n\nArchiving: \n\t"~cmd;
             }
 
             copyDir(inDir, dirName(outDir));
diff --git a/source/redub/building/utils.d b/source/redub/building/utils.d
@@ -60,6 +60,13 @@ auto linkBase(const ThreadBuildData data, CompilingSession session, string rootH
     );
 }
 
+/**
+ * Generates a static library using archiver. FIXME: BuildRequirements should know its files.
+ * Params:
+ *   data = The data containing project information
+ *   s = Compiling Session
+ *   command = Command for being able to print it later
+ */
 auto executeArchiver(const ThreadBuildData data, CompilingSession s, out string command)
 {
     import std.process;
@@ -72,17 +79,25 @@ auto executeArchiver(const ThreadBuildData data, CompilingSession s, out string
     string[] cmd = [a.bin];
     final switch(a.type) with(AcceptedArchiver)
     {
-        case ar, llvmAr: cmd~= "rcs"; break;
+        case ar, llvmAr: cmd~= ["rcs"]; break;
         case libtool: cmd~= ["-static", "-o"]; break;
         case none: break;
     }
 
-    cmd~= getOutputName(data.cfg, s.os, s.isa);
-
-    string objExt = getObjectExtension(s.os);
-    cmd = mapAppend(cmd, data.cfg.sourceFiles, (string src) => stripExtension(src)~ objExt);
+    cmd~= buildNormalizedPath(data.cfg.outputDirectory, getOutputName(data.cfg, s.os, s.isa));
 
+    putObjectFiles(cmd, data.cfg, s.os, s.compiler.compiler.gcc ? cExt : cppExt);
     command = cmd.join(" ");
 
     return executeShell(command);
+}
+
+private void putObjectFiles(ref string[] target, const BuildConfiguration b, OS os, scope const string[] extensions...)
+{
+    import redub.command_generators.commons;
+    import std.file;
+    import std.path;
+    string[] objectFiles;
+    putSourceFiles(objectFiles, b.workingDir, b.sourcePaths, b.sourceFiles, b.excludeSourceFiles, extensions);
+    target = mapAppend(target, objectFiles, (string src) => setExtension(src, getObjectExtension(os)));
 }
diff --git a/source/redub/command_generators/automatic.d b/source/redub/command_generators/automatic.d
@@ -23,12 +23,13 @@ string escapeCompilationCommands(string compilerBin, string[] flags)
  */
 string[] getCompilationFlags(const BuildConfiguration cfg, CompilingSession s, string mainPackHash, bool isRoot)
 {
+    import redub.command_generators.commons;
     switch(s.compiler.compiler) with(AcceptedCompiler)
     {
         case gxx:
-            return redub.command_generators.gnu_based.parseBuildConfiguration(cfg, s, mainPackHash, isRoot, ".c", ".cpp", ".cc", ".i", ".cxx", ".c++");
+            return redub.command_generators.gnu_based.parseBuildConfiguration(cfg, s, mainPackHash, isRoot, cppExt);
         case gcc:
-            return redub.command_generators.gnu_based.parseBuildConfiguration(cfg, s, mainPackHash, isRoot, ".c", ".i");
+            return redub.command_generators.gnu_based.parseBuildConfiguration(cfg, s, mainPackHash, isRoot, cExt);
         case dmd:
             return redub.command_generators.dmd.parseBuildConfiguration(cfg, s, mainPackHash, isRoot);
         case ldc2:
@@ -48,9 +49,7 @@ string[] getLinkFlags(const ThreadBuildData data, CompilingSession s, string mai
 
 string getLinkerBin(Compiler compiler)
 {
-    if(compiler.isDCompiler)
-        return compiler.binOrPath;
-    return compiler.linker.bin;
+    return compiler.binOrPath;
 }
 
 
@@ -61,9 +60,7 @@ string getLinkCommands(const ThreadBuildData data, CompilingSession s, string ma
     if(s.compiler.compiler == AcceptedCompiler.invalid)
         throw new Exception("Unsupported compiler '" ~ s.compiler.binOrPath~"'");
 
-    if(s.compiler.isDCompiler)
-        return escapeShellCommand(s.compiler.binOrPath) ~ " "~ processFlags(flags);
-    return escapeShellCommand(s.compiler.linker.bin) ~ " " ~ processFlags(flags);
+    return escapeShellCommand(s.compiler.binOrPath) ~ " "~ processFlags(flags);
 }
 
 
diff --git a/source/redub/command_generators/commons.d b/source/redub/command_generators/commons.d
@@ -7,6 +7,13 @@ public import redub.compiler_identification;
 import redub.buildapi;
 public import std.file:DirEntry;
 
+///Valid d extensions
+immutable string[] dExt   = [".d"];
+///Valid c extensions
+immutable string[] cExt   = [".c", ".i"];
+///Valid c++ extensions
+immutable string[] cppExt = [".c", ".cpp", ".cc", ".i", ".cxx", ".c++"];
+
 
 OS osFromArch(string arch)
 {
diff --git a/source/redub/command_generators/gnu_based.d b/source/redub/command_generators/gnu_based.d
@@ -4,6 +4,7 @@ public import redub.buildapi;
 public import std.system;
 import redub.command_generators.commons;
 import redub.logging;
+import redub.building.cache;
 
 /// Parse G++ configuration
 string[] parseBuildConfiguration(const BuildConfiguration b, CompilingSession s, string requirementCache, bool isRoot, const string[] extensions...)
@@ -16,6 +17,7 @@ string[] parseBuildConfiguration(const BuildConfiguration b, CompilingSession s,
     with(b)
     {
         if(isDebug) commands~= "-g";
+        if(targetType.isLinkedSeparately) commands~= "-c";
 
         commands = mapAppendPrefix(commands, versions, "-D", false);
         commands~= dFlags;
@@ -29,10 +31,9 @@ string[] parseBuildConfiguration(const BuildConfiguration b, CompilingSession s,
         if(targetType.isLinkedSeparately)
         {
             commands~= "-o";
-            commands ~= buildNormalizedPath(outputDirectory, getOutputName(targetType, name, os));
+            string cacheDir = getCacheOutputDir(requirementCache, b, s, isRoot);
+            commands ~= buildNormalizedPath(cacheDir, getConfigurationOutputName(b, s.os)).escapePath;
         }
-
-
     }
 
     return commands;
diff --git a/source/redub/command_generators/linkers.d b/source/redub/command_generators/linkers.d
@@ -10,30 +10,38 @@ string[] parseLinkConfiguration(const ThreadBuildData data, CompilingSession s,
     import redub.misc.path;
     import redub.building.cache;
     string[] commands;
-    AcceptedLinker linker = s.compiler.linker.type;
+    AcceptedLinker linker = s.compiler.linker;
     bool emitStartGroup = s.isa != ISA.webAssembly && linker != AcceptedLinker.ld64;
 
 
     const BuildConfiguration b = data.cfg;
     with(b)
     {
-        if(s.compiler.isDCompiler)
         {
             import redub.command_generators.d_compilers;
 
             if (targetType.isLinkedSeparately)
             {
                 string cacheDir = getCacheOutputDir(requirementCache, b, s, data.extra.isRoot);
                 string objExtension = getObjectExtension(s.os);
-                commands~= "-of"~buildNormalizedPath(cacheDir, getOutputName(b, s.os)).escapePath;
+                if(s.compiler.isDCompiler)
+                    commands~= "-of"~buildNormalizedPath(cacheDir, getOutputName(b, s.os)).escapePath;
+                else
+                {
+                    commands~= "-o";
+                    commands~= buildNormalizedPath(cacheDir, getOutputName(b, s.os)).escapePath;
+                }
                 if(b.outputsDeps)
                     putSourceFiles(commands, null, [getObjectDir(cacheDir)], null, null, objExtension);
                 else
                     commands~= buildNormalizedPath(outputDirectory, targetName~objExtension).escapePath;
             }
-            string arch = mapArch(s.compiler.compiler, b.arch);
-            if(arch)
-                commands~= arch;
+            if(s.compiler.isDCompiler)
+            {
+                string arch = mapArch(s.compiler.compiler, b.arch);
+                if(arch)
+                    commands~= arch;
+            }
             commands~= filterLinkFlags(b.dFlags);
         }
         if(targetType == TargetType.dynamicLibrary)
@@ -57,13 +65,6 @@ string[] parseLinkConfiguration(const ThreadBuildData data, CompilingSession s,
             commands = mapAppend(commands, libraries, (string l) => "-L-l"~stripLibraryExtension(l));
             
         }
-        else if(!s.compiler.isDCompiler) //Generates a static library using archiver. FIXME: BuildRequirements should know its files.
-        {
-            commands~= "--format=default";
-            commands~= "rcs";
-            commands~= buildNormalizedPath(outputDirectory, getOutputName(b, s.os));
-            putObjectFiles(commands, b, s.os, ".c", ".cpp", ".cc", ".i", ".cxx", ".c++");
-        }
     }
 
     return commands;
@@ -133,11 +134,3 @@ string getTargetTypeFlag(TargetType o, Compiler compiler)
 }
 
 
-private void putObjectFiles(ref string[] target, const BuildConfiguration b, OS os, scope const string[] extensions...)
-{
-    import std.file;
-    import std.path;
-    string[] objectFiles;
-    putSourceFiles(objectFiles, b.workingDir, b.sourcePaths, b.sourceFiles, b.excludeSourceFiles, extensions);
-    target = mapAppend(target, objectFiles, (string src) => setExtension(src, getObjectExtension(os)));
-}
diff --git a/source/redub/compiler_identification.d b/source/redub/compiler_identification.d
@@ -44,11 +44,6 @@ struct Archiver
     AcceptedArchiver type;
     string bin;
 }
-struct Linker
-{
-    AcceptedLinker type;
-    string bin;
-}
 
 AcceptedCompiler acceptedCompilerfromString(string str)
 {
@@ -91,14 +86,6 @@ AcceptedArchiver acceptedArchiverFromString(string str)
     }
 }
 
-private Linker acceptedLinker(JSONValue v)
-{
-    JSONValue* acc = "defaultLinker" in v;
-    if(!acc)
-        return Linker(AcceptedLinker.unknown);
-    return Linker(acceptedLinkerfromString(acc.object["type"].str), acc.object["bin"].str);
-}
-
 private Archiver acceptedArchiver(JSONValue v)
 {
     JSONValue* acc = "defaultArchiver" in v;
@@ -141,7 +128,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.
-    Linker linker = Linker(AcceptedLinker.unknown);
+    AcceptedLinker linker = AcceptedLinker.unknown;
 
 
     string getCompilerString() const
@@ -298,7 +285,7 @@ Compiler getCompiler(string compilerOrPath = "dmd", string compilerAssumption =
     if(ret == Compiler.init)
         ret = inferCompiler(compilerOrPath, compilerAssumption, compilersInfo, isDefault, isGlobal);
 
-    ret.linker = acceptedLinker(compilersInfo);
+    ret.linker = acceptedLinkerfromString(compilersInfo["defaultLinker"].str);
     ret.archiver = acceptedArchiver(compilersInfo);
 
     //Checks for ldc.conf switches to see if it is using gnu linker by default
@@ -436,7 +423,7 @@ private Compiler getCompilerFromCache(JSONValue allCompilersInfo, string compile
                     SemVer(arr[VERSION_].str),
                     SemVer(arr[FRONTEND_VERSION].str),
                     arr[VERSION_STRING].str,
-                    key, acceptedArchiver(allCompilersInfo), false, acceptedLinker(allCompilersInfo)
+                    key, acceptedArchiver(allCompilersInfo), false, acceptedLinkerfromString(allCompilersInfo["defaultLinker"].str)
                 );
             }
         }
@@ -487,14 +474,8 @@ private void saveCompilerInfo(JSONValue allCompilersInfo, ref Compiler compiler,
     }
 
     if(!("defaultLinker" in allCompilersInfo))
-    {
-        JSONValue defaultLinker = JSONValue.emptyObject;
-        auto def = getDefaultLinker();
-        defaultLinker["type"] = def.type.to!string;
-        defaultLinker["bin"] = def.bin;
-        allCompilersInfo["defaultLinker"] = defaultLinker;
-    }
-    compiler.linker = acceptedLinker(allCompilersInfo);
+        allCompilersInfo["defaultLinker"] = getDefaultLinker.to!string;
+    compiler.linker = acceptedLinkerfromString(allCompilersInfo["defaultLinker"].str);
 
     if(!("compilers" in allCompilersInfo))
         allCompilersInfo["compilers"] = JSONValue.emptyObject;
@@ -548,7 +529,7 @@ private Compiler assumeCompiler(string compilerOrPath, string compilerAssumption
 }
 
 
-Linker getDefaultLinker()
+AcceptedLinker getDefaultLinker()
 {
     with(AcceptedLinker)
     {
@@ -560,12 +541,12 @@ Linker getDefaultLinker()
             if(res.status == 0)
             {
                 if(res.output.startsWith("GNU ld"))
-                    return Linker(gnuld, "ld");
+                    return gnuld;
                 else if(res.output.startsWith("@(#)PROGRAM:ld"))
-                    return Linker(ld64, "ld");
+                    return ld64;
             }
         }
-        return Linker(unknown);
+        return unknown;
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -126,13 +126,13 @@ CompilationResult execCompilation(immutable ThreadBuildData data, shared Project`
`126`	`126`	`if(!pack.isCopyEnough)`
`127`	`127`	`ret = cast(ExecutionResult)execCompiler(cfg, compiler.binOrPath, getCompilationFlags(cfg, info, hash.rootHash, data.extra.isRoot), res.compilationCommand, compiler, inDir);`
`128`	`128`
`129`		`- if(!isDCompiler(compiler) && !ret.status) //Always requires link.`
	`129`	`+ if(!isDCompiler(compiler) && !ret.status && isStaticLibrary(data.cfg.targetType)) //Must call archiver when`
`130`	`130`	`{`
`131`	`131`	`string cmd ;`
`132`	`132`	`auto archiverRes = executeArchiver(data, info, cmd);`
`133`	`133`	`ret.status = archiverRes.status;`
`134`	`134`	`ret.output~= archiverRes.output;`
`135`		`- res.compilationCommand~= cmd;`
	`135`	`+ res.compilationCommand~= "\n\nArchiving: \n\t"~cmd;`
`136`	`136`	`}`
`137`	`137`
`138`	`138`	`copyDir(inDir, dirName(outDir));`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@ public import redub.buildapi;`
`4`	`4`	`public import std.system;`
`5`	`5`	`import redub.command_generators.commons;`
`6`	`6`	`import redub.logging;`
	`7`	`+import redub.building.cache;`
`7`	`8`
`8`	`9`	`/// Parse G++ configuration`
`9`	`10`	`string[] parseBuildConfiguration(const BuildConfiguration b, CompilingSession s, string requirementCache, bool isRoot, const string[] extensions...)`
`@@ -16,6 +17,7 @@ string[] parseBuildConfiguration(const BuildConfiguration b, CompilingSession s,`
`16`	`17`	`with(b)`
`17`	`18`	`{`
`18`	`19`	`if(isDebug) commands~= "-g";`
	`20`	`+ if(targetType.isLinkedSeparately) commands~= "-c";`
`19`	`21`
`20`	`22`	`commands = mapAppendPrefix(commands, versions, "-D", false);`
`21`	`23`	`commands~= dFlags;`
`@@ -29,10 +31,9 @@ string[] parseBuildConfiguration(const BuildConfiguration b, CompilingSession s,`
`29`	`31`	`if(targetType.isLinkedSeparately)`
`30`	`32`	`{`
`31`	`33`	`commands~= "-o";`
`32`		`- commands ~= buildNormalizedPath(outputDirectory, getOutputName(targetType, name, os));`
	`34`	`+ string cacheDir = getCacheOutputDir(requirementCache, b, s, isRoot);`
	`35`	`+ commands ~= buildNormalizedPath(cacheDir, getConfigurationOutputName(b, s.os)).escapePath;`
`33`	`36`	`}`
`34`		`-`
`35`		`-`
`36`	`37`	`}`
`37`	`38`
`38`	`39`	`return commands;`
Original file line number	Diff line number	Diff line change
`@@ -44,11 +44,6 @@ struct Archiver`
`44`	`44`	`AcceptedArchiver type;`
`45`	`45`	`string bin;`
`46`	`46`	`}`
`47`		`-struct Linker`
`48`		`-{`
`49`		`- AcceptedLinker type;`
`50`		`- string bin;`
`51`		`-}`
`52`	`47`
`53`	`48`	`AcceptedCompiler acceptedCompilerfromString(string str)`
`54`	`49`	`{`
`@@ -91,14 +86,6 @@ AcceptedArchiver acceptedArchiverFromString(string str)`
`91`	`86`	`}`
`92`	`87`	`}`
`93`	`88`
`94`		`-private Linker acceptedLinker(JSONValue v)`
`95`		`-{`
`96`		`- JSONValue* acc = "defaultLinker" in v;`
`97`		`- if(!acc)`
`98`		`- return Linker(AcceptedLinker.unknown);`
`99`		`- return Linker(acceptedLinkerfromString(acc.object["type"].str), acc.object["bin"].str);`
`100`		`-}`
`101`		`-`
`102`	`89`	`private Archiver acceptedArchiver(JSONValue v)`
`103`	`90`	`{`
`104`	`91`	`JSONValue* acc = "defaultArchiver" in v;`
`@@ -141,7 +128,7 @@ struct Compiler`
`141`	`128`
`142`	`129`	`///Currently unused. Was used before for checking whether --start-group should be emitted or not. Since it is emitted`
`143`	`130`	`///by default, only on webAssembly which is not, it lost its usage for now.`
`144`		`- Linker linker = Linker(AcceptedLinker.unknown);`
	`131`	`+ AcceptedLinker linker = AcceptedLinker.unknown;`
`145`	`132`
`146`	`133`
`147`	`134`	`string getCompilerString() const`
`@@ -298,7 +285,7 @@ Compiler getCompiler(string compilerOrPath = "dmd", string compilerAssumption =`
`298`	`285`	`if(ret == Compiler.init)`
`299`	`286`	`ret = inferCompiler(compilerOrPath, compilerAssumption, compilersInfo, isDefault, isGlobal);`
`300`	`287`
`301`		`- ret.linker = acceptedLinker(compilersInfo);`
	`288`	`+ ret.linker = acceptedLinkerfromString(compilersInfo["defaultLinker"].str);`
`302`	`289`	`ret.archiver = acceptedArchiver(compilersInfo);`
`303`	`290`
`304`	`291`	`//Checks for ldc.conf switches to see if it is using gnu linker by default`
`@@ -436,7 +423,7 @@ private Compiler getCompilerFromCache(JSONValue allCompilersInfo, string compile`
`436`	`423`	`SemVer(arr[VERSION_].str),`
`437`	`424`	`SemVer(arr[FRONTEND_VERSION].str),`
`438`	`425`	`arr[VERSION_STRING].str,`
`439`		`- key, acceptedArchiver(allCompilersInfo), false, acceptedLinker(allCompilersInfo)`
	`426`	`+ key, acceptedArchiver(allCompilersInfo), false, acceptedLinkerfromString(allCompilersInfo["defaultLinker"].str)`
`440`	`427`	`);`
`441`	`428`	`}`
`442`	`429`	`}`
`@@ -487,14 +474,8 @@ private void saveCompilerInfo(JSONValue allCompilersInfo, ref Compiler compiler,`
`487`	`474`	`}`
`488`	`475`
`489`	`476`	`if(!("defaultLinker" in allCompilersInfo))`
`490`		`- {`
`491`		`- JSONValue defaultLinker = JSONValue.emptyObject;`
`492`		`- auto def = getDefaultLinker();`
`493`		`- defaultLinker["type"] = def.type.to!string;`
`494`		`- defaultLinker["bin"] = def.bin;`
`495`		`- allCompilersInfo["defaultLinker"] = defaultLinker;`
`496`		`- }`
`497`		`- compiler.linker = acceptedLinker(allCompilersInfo);`
	`477`	`+ allCompilersInfo["defaultLinker"] = getDefaultLinker.to!string;`
	`478`	`+ compiler.linker = acceptedLinkerfromString(allCompilersInfo["defaultLinker"].str);`
`498`	`479`
`499`	`480`	`if(!("compilers" in allCompilersInfo))`
`500`	`481`	`allCompilersInfo["compilers"] = JSONValue.emptyObject;`
`@@ -548,7 +529,7 @@ private Compiler assumeCompiler(string compilerOrPath, string compilerAssumption`
`548`	`529`	`}`
`549`	`530`
`550`	`531`
`551`		`-Linker getDefaultLinker()`
	`532`	`+AcceptedLinker getDefaultLinker()`
`552`	`533`	`{`
`553`	`534`	`with(AcceptedLinker)`
`554`	`535`	`{`
`@@ -560,12 +541,12 @@ Linker getDefaultLinker()`
`560`	`541`	`if(res.status == 0)`
`561`	`542`	`{`
`562`	`543`	`if(res.output.startsWith("GNU ld"))`
`563`		`- return Linker(gnuld, "ld");`
	`544`	`+ return gnuld;`
`564`	`545`	`else if(res.output.startsWith("@(#)PROGRAM:ld"))`
`565`		`- return Linker(ld64, "ld");`
	`546`	`+ return ld64;`
`566`	`547`	`}`
`567`	`548`	`}`
`568`		`- return Linker(unknown);`
	`549`	`+ return unknown;`
`569`	`550`	`}`
`570`	`551`	`}`
`571`	`552`