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 }