Newer
Older
dub_jkp / source / dub / compilers / ldc.d
@WebFreak001 WebFreak001 on 26 Jan 2023 10 KB reduce dependency on the working directory
  1. /**
  2. LDC compiler support.
  3.  
  4. Copyright: © 2013-2013 rejectedsoftware e.K.
  5. License: Subject to the terms of the MIT license, as written in the included LICENSE.txt file.
  6. Authors: Sönke Ludwig
  7. */
  8. module dub.compilers.ldc;
  9.  
  10. import dub.compilers.compiler;
  11. import dub.compilers.utils;
  12. import dub.internal.utils;
  13. import dub.internal.vibecompat.core.file;
  14. import dub.internal.vibecompat.inet.path;
  15. import dub.internal.logging;
  16.  
  17. import std.algorithm;
  18. import std.array;
  19. import std.exception;
  20. import std.typecons;
  21.  
  22.  
  23. class LDCCompiler : Compiler {
  24. private static immutable s_options = [
  25. tuple(BuildOption.debugMode, ["-d-debug"]),
  26. tuple(BuildOption.releaseMode, ["-release"]),
  27. tuple(BuildOption.coverage, ["-cov"]),
  28. tuple(BuildOption.coverageCTFE, ["-cov=ctfe"]),
  29. tuple(BuildOption.debugInfo, ["-g"]),
  30. tuple(BuildOption.debugInfoC, ["-gc"]),
  31. tuple(BuildOption.alwaysStackFrame, ["-disable-fp-elim"]),
  32. //tuple(BuildOption.stackStomping, ["-?"]),
  33. tuple(BuildOption.inline, ["-enable-inlining", "-Hkeep-all-bodies"]),
  34. tuple(BuildOption.noBoundsCheck, ["-boundscheck=off"]),
  35. tuple(BuildOption.optimize, ["-O3"]),
  36. tuple(BuildOption.profile, ["-fdmd-trace-functions"]),
  37. tuple(BuildOption.unittests, ["-unittest"]),
  38. tuple(BuildOption.verbose, ["-v"]),
  39. tuple(BuildOption.ignoreUnknownPragmas, ["-ignore"]),
  40. tuple(BuildOption.syntaxOnly, ["-o-"]),
  41. tuple(BuildOption.warnings, ["-wi"]),
  42. tuple(BuildOption.warningsAsErrors, ["-w"]),
  43. tuple(BuildOption.ignoreDeprecations, ["-d"]),
  44. tuple(BuildOption.deprecationWarnings, ["-dw"]),
  45. tuple(BuildOption.deprecationErrors, ["-de"]),
  46. tuple(BuildOption.property, ["-property"]),
  47. //tuple(BuildOption.profileGC, ["-?"]),
  48. tuple(BuildOption.betterC, ["-betterC"]),
  49. tuple(BuildOption.lowmem, ["-lowmem"]),
  50. tuple(BuildOption.color, ["-enable-color"]),
  51.  
  52. tuple(BuildOption._docs, ["-Dd=docs"]),
  53. tuple(BuildOption._ddox, ["-Xf=docs.json", "-Dd=__dummy_docs"]),
  54. ];
  55.  
  56. @property string name() const { return "ldc"; }
  57.  
  58. enum ldcVersionRe = `^version\s+v?(\d+\.\d+\.\d+[A-Za-z0-9.+-]*)`;
  59.  
  60. unittest {
  61. import std.regex : matchFirst, regex;
  62. auto probe = `
  63. binary /usr/bin/ldc2
  64. version 1.11.0 (DMD v2.081.2, LLVM 6.0.1)
  65. config /etc/ldc2.conf (x86_64-pc-linux-gnu)
  66. `;
  67. auto re = regex(ldcVersionRe, "m");
  68. auto c = matchFirst(probe, re);
  69. assert(c && c.length > 1 && c[1] == "1.11.0");
  70. }
  71.  
  72. string determineVersion(string compiler_binary, string verboseOutput)
  73. {
  74. import std.regex : matchFirst, regex;
  75. auto ver = matchFirst(verboseOutput, regex(ldcVersionRe, "m"));
  76. return ver && ver.length > 1 ? ver[1] : null;
  77. }
  78.  
  79. BuildPlatform determinePlatform(ref BuildSettings settings, string compiler_binary, string arch_override)
  80. {
  81. string[] arch_flags;
  82. switch (arch_override) {
  83. case "": break;
  84. case "x86": arch_flags = ["-march=x86"]; break;
  85. case "x86_mscoff": arch_flags = ["-march=x86"]; break;
  86. case "x86_64": arch_flags = ["-march=x86-64"]; break;
  87. case "aarch64": arch_flags = ["-march=aarch64"]; break;
  88. case "powerpc64": arch_flags = ["-march=powerpc64"]; break;
  89. default:
  90. if (arch_override.canFind('-'))
  91. arch_flags = ["-mtriple="~arch_override];
  92. else
  93. throw new UnsupportedArchitectureException(arch_override);
  94. break;
  95. }
  96. settings.addDFlags(arch_flags);
  97.  
  98. return probePlatform(
  99. compiler_binary,
  100. arch_flags ~ ["-c", "-o-", "-v"],
  101. arch_override
  102. );
  103. }
  104.  
  105. void prepareBuildSettings(ref BuildSettings settings, const scope ref BuildPlatform platform, BuildSetting fields = BuildSetting.all) const
  106. {
  107. import std.format : format;
  108. enforceBuildRequirements(settings);
  109.  
  110. if (!(fields & BuildSetting.options)) {
  111. foreach (t; s_options)
  112. if (settings.options & t[0])
  113. settings.addDFlags(t[1]);
  114. }
  115.  
  116. // since LDC always outputs multiple object files, avoid conflicts by default
  117. settings.addDFlags("--oq", format("-od=%s/obj", settings.targetPath));
  118.  
  119. if (!(fields & BuildSetting.versions)) {
  120. settings.addDFlags(settings.versions.map!(s => "-d-version="~s)().array());
  121. settings.versions = null;
  122. }
  123.  
  124. if (!(fields & BuildSetting.debugVersions)) {
  125. settings.addDFlags(settings.debugVersions.map!(s => "-d-debug="~s)().array());
  126. settings.debugVersions = null;
  127. }
  128.  
  129. if (!(fields & BuildSetting.importPaths)) {
  130. settings.addDFlags(settings.importPaths.map!(s => "-I"~s)().array());
  131. settings.importPaths = null;
  132. }
  133.  
  134. if (!(fields & BuildSetting.stringImportPaths)) {
  135. settings.addDFlags(settings.stringImportPaths.map!(s => "-J"~s)().array());
  136. settings.stringImportPaths = null;
  137. }
  138.  
  139. if (!(fields & BuildSetting.sourceFiles)) {
  140. settings.addDFlags(settings.sourceFiles);
  141. settings.sourceFiles = null;
  142. }
  143.  
  144. if (!(fields & BuildSetting.libs)) {
  145. resolveLibs(settings, platform);
  146. settings.addLFlags(settings.libs.map!(l => "-l"~l)().array());
  147. }
  148.  
  149. if (!(fields & BuildSetting.lflags)) {
  150. settings.addDFlags(lflagsToDFlags(settings.lflags));
  151. settings.lflags = null;
  152. }
  153.  
  154. if (settings.options & BuildOption.pic) {
  155. if (platform.isWindows()) {
  156. /* This has nothing to do with PIC, but as the PIC option is exclusively
  157. * set internally for code that ends up in a dynamic library, explicitly
  158. * specify what `-shared` defaults to (`-shared` can't be used when
  159. * compiling only, without linking).
  160. * *Pre*pending the flags enables the user to override them.
  161. */
  162. settings.prependDFlags("-fvisibility=public", "-dllimport=all");
  163. } else {
  164. settings.addDFlags("-relocation-model=pic");
  165. }
  166. }
  167.  
  168. assert(fields & BuildSetting.dflags);
  169. assert(fields & BuildSetting.copyFiles);
  170. }
  171.  
  172. void extractBuildOptions(ref BuildSettings settings) const
  173. {
  174. Appender!(string[]) newflags;
  175. next_flag: foreach (f; settings.dflags) {
  176. foreach (t; s_options)
  177. if (t[1].canFind(f)) {
  178. settings.options |= t[0];
  179. continue next_flag;
  180. }
  181. if (f.startsWith("-d-version=")) settings.addVersions(f[11 .. $]);
  182. else if (f.startsWith("-d-debug=")) settings.addDebugVersions(f[9 .. $]);
  183. else newflags ~= f;
  184. }
  185. settings.dflags = newflags.data;
  186. }
  187.  
  188. string getTargetFileName(in BuildSettings settings, in BuildPlatform platform)
  189. const {
  190. assert(settings.targetName.length > 0, "No target name set.");
  191.  
  192. const p = platform.platform;
  193. final switch (settings.targetType) {
  194. case TargetType.autodetect: assert(false, "Configurations must have a concrete target type.");
  195. case TargetType.none: return null;
  196. case TargetType.sourceLibrary: return null;
  197. case TargetType.executable:
  198. if (p.canFind("windows"))
  199. return settings.targetName ~ ".exe";
  200. else if (p.canFind("wasm"))
  201. return settings.targetName ~ ".wasm";
  202. else return settings.targetName.idup;
  203. case TargetType.library:
  204. case TargetType.staticLibrary:
  205. if (p.canFind("windows") && !p.canFind("mingw"))
  206. return settings.targetName ~ ".lib";
  207. else return "lib" ~ settings.targetName ~ ".a";
  208. case TargetType.dynamicLibrary:
  209. if (p.canFind("windows"))
  210. return settings.targetName ~ ".dll";
  211. else if (p.canFind("darwin"))
  212. return "lib" ~ settings.targetName ~ ".dylib";
  213. else return "lib" ~ settings.targetName ~ ".so";
  214. case TargetType.object:
  215. if (p.canFind("windows"))
  216. return settings.targetName ~ ".obj";
  217. else return settings.targetName ~ ".o";
  218. }
  219. }
  220.  
  221. void setTarget(ref BuildSettings settings, in BuildPlatform platform, string tpath = null) const
  222. {
  223. const targetFileName = getTargetFileName(settings, platform);
  224.  
  225. final switch (settings.targetType) {
  226. case TargetType.autodetect: assert(false, "Invalid target type: autodetect");
  227. case TargetType.none: assert(false, "Invalid target type: none");
  228. case TargetType.sourceLibrary: assert(false, "Invalid target type: sourceLibrary");
  229. case TargetType.executable: break;
  230. case TargetType.library:
  231. case TargetType.staticLibrary:
  232. settings.addDFlags("-lib");
  233. break;
  234. case TargetType.dynamicLibrary:
  235. settings.addDFlags("-shared");
  236. addDynamicLibName(settings, platform, targetFileName);
  237. break;
  238. case TargetType.object:
  239. settings.addDFlags("-c");
  240. break;
  241. }
  242.  
  243. if (tpath is null)
  244. tpath = (NativePath(settings.targetPath) ~ targetFileName).toNativeString();
  245. settings.addDFlags("-of"~tpath);
  246. }
  247.  
  248. void invoke(in BuildSettings settings, in BuildPlatform platform, void delegate(int, string) output_callback, NativePath cwd)
  249. {
  250. auto res_file = getTempFile("dub-build", ".rsp");
  251. const(string)[] args = settings.dflags;
  252. if (platform.frontendVersion >= 2066) args ~= "-vcolumns";
  253. writeFile(res_file, escapeArgs(args).join("\n"));
  254.  
  255. logDiagnostic("%s %s", platform.compilerBinary, escapeArgs(args).join(" "));
  256. string[string] env;
  257. foreach (aa; [settings.environments, settings.buildEnvironments])
  258. foreach (k, v; aa)
  259. env[k] = v;
  260. invokeTool([platform.compilerBinary, "@"~res_file.toNativeString()], output_callback, cwd, env);
  261. }
  262.  
  263. void invokeLinker(in BuildSettings settings, in BuildPlatform platform, string[] objects, void delegate(int, string) output_callback, NativePath cwd)
  264. {
  265. import std.string;
  266. auto tpath = NativePath(settings.targetPath) ~ getTargetFileName(settings, platform);
  267. auto args = ["-of"~tpath.toNativeString()];
  268. args ~= objects;
  269. args ~= settings.sourceFiles;
  270. if (platform.platform.canFind("linux"))
  271. args ~= "-L--no-as-needed"; // avoids linker errors due to libraries being specified in the wrong order
  272. args ~= lflagsToDFlags(settings.lflags);
  273. args ~= settings.dflags.filter!(f => isLinkerDFlag(f)).array;
  274.  
  275. auto res_file = getTempFile("dub-build", ".lnk");
  276. writeFile(res_file, escapeArgs(args).join("\n"));
  277.  
  278. logDiagnostic("%s %s", platform.compilerBinary, escapeArgs(args).join(" "));
  279. string[string] env;
  280. foreach (aa; [settings.environments, settings.buildEnvironments])
  281. foreach (k, v; aa)
  282. env[k] = v;
  283. invokeTool([platform.compilerBinary, "@"~res_file.toNativeString()], output_callback, cwd, env);
  284. }
  285.  
  286. string[] lflagsToDFlags(const string[] lflags) const
  287. {
  288. return map!(f => "-L"~f)(lflags.filter!(f => f != "")()).array();
  289. }
  290.  
  291. private auto escapeArgs(in string[] args)
  292. {
  293. return args.map!(s => s.canFind(' ') ? "\""~s~"\"" : s);
  294. }
  295.  
  296. static bool isLinkerDFlag(string arg)
  297. {
  298. if (arg.length > 2 && arg.startsWith("--"))
  299. arg = arg[1 .. $]; // normalize to 1 leading hyphen
  300.  
  301. switch (arg) {
  302. case "-g", "-gc", "-m32", "-m64", "-shared", "-lib",
  303. "-betterC", "-disable-linker-strip-dead", "-static":
  304. return true;
  305. default:
  306. return arg.startsWith("-L")
  307. || arg.startsWith("-Xcc=")
  308. || arg.startsWith("-defaultlib=")
  309. || arg.startsWith("-platformlib=")
  310. || arg.startsWith("-flto")
  311. || arg.startsWith("-fsanitize=")
  312. || arg.startsWith("-gcc=")
  313. || arg.startsWith("-link-")
  314. || arg.startsWith("-linker=")
  315. || arg.startsWith("-march=")
  316. || arg.startsWith("-mscrtlib=")
  317. || arg.startsWith("-mtriple=");
  318. }
  319. }
  320. }