Added: Redub cross compile target support

Author: MrcSnm

README.md

@@ -21,6 +21,9 @@ Those are the additions I've made over dub
 - [**Library API**](#using-its-library-api) - Integrate redub directly in your application
 - **Watching Directories** - `redub watch`- Builds dependents automatically on changes. Add  `--run` to run the program after building.
 - **MacOS Universal Builds** - `redub build-universal` - Generates a single binary containing arm64 and x86_64 architectures on MacOS
+- [**Redub Executable Icons**](#redub-executable-icons) - Adds inside the recipe file a way to define how your program icon will look
+- [**Linker Diagnostics**](#redub-linker-diagnostics) - Experimental support to improve linker message errors.
+- [**Cross Compilation Targets**](#redub-cross-compile) - Adds support to build targets, selecting a compiler, architecture and other configuration by just calling `redub --target=PSVita`
 
 
 ## Redub Help
@@ -123,6 +126,59 @@ You can also control the bundle configurations by using. Failing to use a valid
 }
 ```
 
+
+## Redub Linker Diagnostics
+- **1.29.0**: Added Windows Linker Diagnostics.
+
+Sometimes people may get cryptic error messages regarding anundefined __ModuleInitZ symbol. Since Redub already had information on how each module imports each other, I've ended up adding support to improve the linker messages as that may reduce by a lot iteration time. Example:
+
+```
+hipreme_engine.obj : error LNK2001: unresolved external symbol _D3hip3api12__ModuleInfoZ
+C:\Users\Hipreme\AppData\Local\.dub\.redub\1AB9D53797DC3516\1AB9D53797DC3516\hipreme_engine.exe : fatal error LNK1120: 1 unresolved external symbol
+Error: C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\VC\Tools\MSVC\14.44.35207\bin\HostX64\x64\link.exe failed
+with status: 1120
+```
+This gets one additional message
+
+```
+Redub Help Message: Module hip.api is imported by:
+        hip.view.load_scene (C:\Users\Hipreme\Documents\D\HipremeEngine\source\hip\view\load_scene.d)
+```
+
+## Redub Cross Compile
+- **1.30.0**: Added cross compilation definition support via the `--target` flag.
+
+Ever wanted to configure a default compiler/arch based on the configuration? Now you can (mostly). This is an example on how a `target` will look in your recipe JSON:
+
+```json
+{
+  "name": "my-project",
+  "targets": {
+    "wasm": {
+      "compiler": "ldc2",
+      "arch": "wasm32-unknown-unknown-wasm"
+    },
+    "PSVita": {
+      "compiler": "ldc2",
+      "arch": "armv7a-unknown-unknown-eabi",
+      "dflags": [
+        "--revert=dtorfields",
+        "-mcpu=cortex-a9",
+        "-mattr=+neon,+neonfp,+thumb-mode",
+        "-fvisibility=hidden",
+        "-gcc=$VITASDK/bin/arm-vita-eabi-gcc",
+        "--relocation-model=static"
+      ],
+      "versions": ["PSVita"],
+      "dependencies": {
+        "custom-rt": {"path": "my/custom/runtime"}
+      }
+    }
+  }
+}
+```
+Now you can just call `redub --target=wasm` or `redub --target=PSVita` and every dependency will inherit this configuration.
+
 ## Multi language
 
 Redub has also an experimental support for building and linking C/C++ code together with D code. For that, you need to define a dub.json:

dub.selections.json

@@ -1,21 +1,29 @@
 {
 	"fileVersion": 1,
 	"versions": {
-		"adv_diff":  {"path": "adv_diff"},
-		"hipjson": "1.1.2",
+		"adv_diff": {"path":"adv_diff"},
+		"arsd-official": "12.1.2",
+		"asdf": "0.7.17",
+		"colorize": {"path":"colorize"},
 		"d-segmented-hashmap": "1.1.0",
-		"murmurhash-d": "1.0.0",
+		"d_dependencies": {"path":"d_dependencies"},
+		"d_downloader": {"path":"d_downloader"},
+		"dub_sdl_to_json": {"path":"dub_sdl_to_json"},
+		"fswatch": "0.6.1",
+		"hipjson": "1.1.2",
 		"intel-intrinsics": "1.14.7",
-		"arsd-official": "12.1.2",
-		"colorize":  {"path": "colorize"},
-		"d_dependencies":  {"path": "d_dependencies"},
-		"d_downloader":  {"path": "d_downloader"},
-		"dub_sdl_to_json":  {"path": "dub_sdl_to_json"},
+		"iopipe": "0.2.5",
+		"jsoniopipe": "0.1.4",
+		"mir-algorithm": "3.22.4",
+		"mir-core": "1.7.4",
+		"mir-cpuid": "1.2.11",
+		"mir-ion": "2.3.5",
+		"murmurhash-d": "1.0.0",
+		"package_suppliers": {"path":"package_suppliers"},
 		"sdlite": "1.3.4",
+		"semver": {"path":"semver"},
+		"silly": "1.1.1",
 		"taggedalgebraic": "1.0.1",
-		"fswatch": "0.6.1",
-		"package_suppliers":  {"path": "package_suppliers"},
-		"semver":  {"path": "semver"},
 		"xxhash3": "0.0.5"
 	}
-}
+}

source/redub/api.d

@@ -132,6 +132,7 @@ struct ArgsDetails
     ProjectToParse proj;
     InitialDubVariables dubVars;
     string buildType;
+    string target;
 
     ResolveInfo resolveInfo() const { return ResolveInfo.fromArgs(this); }
 }
@@ -741,7 +742,7 @@ ArgsDetails resolveArguments(string[] args, bool isDescribeOnly = false)
         CompilationDetails(bArgs.compiler, bArgs.cCompiler, bArgs.arch, bArgs.compilerAssumption, bArgs.build.incremental, bArgs.build.useExistingObj, bArgs.build.combined, bArgs.build.parallel),
         ProjectToParse(bArgs.config, workingDir, subPackage, recipe, bArgs.single.length != 0, isDescribeOnly),
         getInitialDubVariablesFromArguments(bArgs, DubBuildArguments.init, os, args),
-        bt
+        bt, bArgs.target
     );
 }
 
@@ -761,7 +762,8 @@ ProjectDetails resolveDependencies(
     CompilationDetails cDetails = CompilationDetails.init,
     ProjectToParse proj = ProjectToParse.init,
     InitialDubVariables dubVars = InitialDubVariables.init,
-    string buildType = BuildType.debug_
+    string buildType = BuildType.debug_,
+    string target = null
 )
 {
     import std.datetime.stopwatch;
@@ -799,35 +801,40 @@ ProjectDetails resolveDependencies(
         proj.workingDir = std.file.getcwd;
     }
 
-    BuildRequirements req;
+    RootParseResult res;
     if(proj.isSingle)
-        req = redub.parsers.single.parseProject(
+        res = redub.parsers.single.parseProject(
             proj.workingDir,
             cInfo,
             BuildRequirements.Configuration(proj.configuration, false),
             proj.subPackage,
             proj.recipe,
+            target,
             cDetails.useExistingObj
         );
     else
-        req = redub.parsers.automatic.parseProject(
+        res = redub.parsers.automatic.parseProject(
             proj.workingDir,
             cInfo,
             BuildRequirements.Configuration(proj.configuration, false),
             proj.subPackage,
             proj.recipe,
+            target,
             cDetails.useExistingObj,
             proj.isDescribeOnly
         );
+    
+    ///Change the compiler to use the possibly new cInfo.compiler
+    compiler = res.targetCompilationInfo.compilers;
 
-    CompilerBinary cBin = req.cfg.getCompiler(compiler);
-    redub.parsers.environment.setupEnvironmentVariablesForRootPackage(req);
+    CompilerBinary cBin = res.mainRequirement.cfg.getCompiler(compiler);
+    redub.parsers.environment.setupEnvironmentVariablesForRootPackage(res.mainRequirement);
     if(cDetails.includeEnvironmentVariables)
-        req.cfg = req.cfg.merge(redub.parsers.environment.parse());
+        res.mainRequirement.cfg = res.mainRequirement.cfg.merge(redub.parsers.environment.parse());
 
-    req.cfg = req.cfg.merge(redub.parsers.build_type.parse(buildType, cBin));
+    res.mainRequirement.cfg = res.mainRequirement.cfg.merge(redub.parsers.build_type.parse(buildType, cBin));
 
-    ProjectNode tree = getProjectTree(req, cInfo);
+    ProjectNode tree = getProjectTree(res);
 
     if(cDetails.combinedBuild)
         tree.combine();

source/redub/buildapi.d

@@ -7,7 +7,7 @@ import redub.package_searching.api;
 
 
 ///vX.X.X
-enum RedubVersionOnly = "v1.29.2";
+enum RedubVersionOnly = "v1.30.0";
 ///Redub vX.X.X
 enum RedubVersionShort = "Redub "~RedubVersionOnly;
 ///Redub vX.X.X - Description
@@ -59,6 +59,29 @@ struct CompilingSession
     }
 }
 
+struct CompilationInfo
+{
+    Compiler compilers;
+    string compiler() const {return compilers.d.getCompilerString; }
+    string c_compiler() const {return compilers.c.getCompilerString; }
+    string binPath() const {return compilers.d.bin; }
+    ///Where the actual compiler is. Used for plugin building
+    string arch;
+
+    OS targetOS() const
+    {
+        import redub.command_generators.commons;
+        return osFromArch(arch); 
+    }
+    ///Target Instruction Set Architecture
+    ISA isa() const
+    {
+        import redub.command_generators.commons;
+        return isaFromArch(arch); 
+    }
+}
+
+
 enum BundleCategories : string
 {
     audioVideo = "AudioVideo",
@@ -736,6 +759,13 @@ string getVisibilityString(Visibility vis)
     }
 }
 
+struct RootParseResult
+{
+    BuildRequirements mainRequirement;
+    BuildRequirements targetRequirement;
+    CompilationInfo targetCompilationInfo;
+}
+
 struct Dependency
 {
     string name;
@@ -966,8 +996,10 @@ class ProjectNode
         );
     }
 
-    this(BuildRequirements req, bool isOptional)
+    this(BuildRequirements req, bool isOptional, BuildRequirements targetRequirement)
     {
+        if(targetRequirement != BuildRequirements.init)
+            req = req.merge(targetRequirement);
         this.requirements = req;
         this._isOptional = isOptional;
     }

source/redub/cli/dub.d

@@ -218,6 +218,9 @@ struct DubArguments
 
     @("If a dub.selections.json is present, all non-path based packages are prefetched. Best for action runners.")
     bool prefetch;
+
+    @("Set which target to build. target json example definition: \"targets\": {\"windmd\": {\"compiler\": \"dmd\"}}")
+    string target;
 }
 
 

source/redub/extensions/cli.d

@@ -24,7 +24,8 @@ ProjectDetails resolveDependencies(string[] args, bool isDescribeOnly = false)
         argsD.cDetails,
         argsD.proj,
         argsD.dubVars,
-        argsD.buildType
+        argsD.buildType,
+        argsD.target
     );
 
     if(argsD.args.targetPath)

source/redub/parsers/automatic.d

@@ -24,12 +24,13 @@ import hip.data.json;
  *   isDescribeOnly = Do not execute preGenerate commands when true
  * Returns: The build requirements to the project. Not recursive.
  */
-BuildRequirements parseProject(
+RootParseResult parseProject(
     string projectWorkingDir,
     ref CompilationInfo cInfo,
     BuildRequirements.Configuration subConfiguration,
     string subPackage,
     string recipe,
+    string target,
     bool useExistingObj = false,
     bool isDescribeOnly = false
 )
@@ -56,7 +57,7 @@ BuildRequirements parseProject(
     }
 
     JSONValue projectJSON = getProjectJSON(projectFile, projectWorkingDir);
-    return parseProject(projectJSON, projectWorkingDir, cInfo, subConfiguration, subPackage, useExistingObj, isDescribeOnly);
+    return parseProject(projectJSON, projectWorkingDir, cInfo, subConfiguration, subPackage, target, useExistingObj, isDescribeOnly);
 }
 
 /**
@@ -73,25 +74,37 @@ BuildRequirements parseProject(
  *   isDescribeOnly = Do not execute preGenerate commands when true
  * Returns: The build requirements to the project. Not recursive.
  */
-BuildRequirements parseProject(
+RootParseResult parseProject(
     JSONValue projectJSON,
     string projectWorkingDir,
-    ref CompilationInfo cInfo,
+    CompilationInfo cInfo,
     BuildRequirements.Configuration subConfiguration,
     string subPackage,
+    string target,
     bool useExistingObj = false,
     bool isDescribeOnly = false
 )
 {
     import redub.parsers.base;
 
+    RootParseResult result;
+
     ParseConfig cfg = getParseConfig(projectWorkingDir, cInfo, null, null, subConfiguration, subPackage, null, isDescribeOnly);
-        //Get target
 
-    // cfg = redub.parsers.json.getTarget(projectJSON, null, cfg);
+    if(target.length)
+    {
+        import redub.parsers.json;
+        TargetInfo targetInfo = redub.parsers.json.getTarget(projectJSON, target, cfg);
+        cfg = targetInfo.parseConfig;
+        cInfo = cfg.cInfo;
+        result.targetRequirement = postProcessBuildRequirements(targetInfo.targetRequirement, targetInfo.pending, cInfo, false, useExistingObj);
+    }
+    result.targetCompilationInfo = cInfo;
     BuildConfiguration pending;
-    BuildRequirements req = redub.parsers.json.parse(projectJSON, cfg, pending, true);
-    return postProcessBuildRequirements(req, pending, cInfo, true, useExistingObj);
+    result.mainRequirement = redub.parsers.json.parse(projectJSON, cfg, pending, true);
+    result.mainRequirement= postProcessBuildRequirements(result.mainRequirement, pending, cInfo, true, useExistingObj);
+
+    return result;
 }
 
 

source/redub/parsers/json.d

@@ -8,6 +8,7 @@ import std.file;
 import redub.command_generators.commons;
 import core.runtime;
 import redub.tree_generators.dub;
+import core.stdcpp.type_traits;
 
 /**
  * Those commands are independent of the selected target OS.
@@ -27,8 +28,22 @@ string getPackageName(JSONValue packageJSON)
     return packageJSON["name"].str;
 }
 
+struct TargetInfo
+{
+    ParseConfig parseConfig;
+    BuildConfiguration pending;
+    BuildRequirements targetRequirement;
+}
 
-ParseConfig getTarget(JSONValue value, string target, ParseConfig cfg)
+/** 
+ * Gets target information from the place setup. Used mostly for crosscompilation, auto compiler/arch setup.
+ * Params:
+ *   value = The "targets" JSONValue
+ *   target = The actual target to get
+ *   cfg = Base ParseConfig containing compiler/arch. Might be unused
+ * Returns: TargetInfo with the pending buildconfiguration, a new valid parseConfig to use instead of the `cfg` argument and the targetRequirement
+ */
+TargetInfo getTarget(JSONValue value, string target, ParseConfig cfg)
 {
     JSONValue* targets = "targets" in value;
     if(targets is null)
@@ -42,11 +57,18 @@ ParseConfig getTarget(JSONValue value, string target, ParseConfig cfg)
             availableTargets~= "\n\t"~key;
         throw new Exception(availableTargets);
     }
-    ParseConfig ret = cfg;
-    // ret.cInfo.
-
-
-    return cfg;
+    TargetInfo ret;
+    ret.parseConfig = cfg;
+
+    string compiler = tryGetStr(*actualTarget, "compiler");
+    string arch = tryGetStr(*actualTarget, "arch");
+    if(compiler) ret.parseConfig.cInfo.compilers = getCompiler(compiler);
+    if(arch) ret.parseConfig.cInfo.arch = arch;
+
+    ///This line is necessary as it errors if no requiredBy is pressent and no name is present.
+    cfg.extra.requiredBy = target;
+    ret.targetRequirement = parse(*actualTarget, cfg, ret.pending, false);
+    return ret;
 }