1 /** 2 GDC 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.gdc; 9 10 import dub.compilers.compiler; 11 import dub.compilers.utils; 12 import dub.internal.utils; 13 import dub.internal.vibecompat.core.log; 14 import dub.internal.vibecompat.inet.path; 15 16 import std.algorithm; 17 import std.array; 18 import std.exception; 19 import std.file; 20 import std.process; 21 import std.typecons; 22 23 24 class GDCCompiler : Compiler { 25 private static immutable s_options = [ 26 tuple(BuildOption.debugMode, ["-fdebug"]), 27 tuple(BuildOption.releaseMode, ["-frelease"]), 28 tuple(BuildOption.coverage, ["-fprofile-arcs", "-ftest-coverage"]), 29 tuple(BuildOption.debugInfo, ["-g"]), 30 tuple(BuildOption.debugInfoC, ["-g", "-fdebug-c"]), 31 //tuple(BuildOption.alwaysStackFrame, ["-X"]), 32 //tuple(BuildOption.stackStomping, ["-X"]), 33 tuple(BuildOption.inline, ["-finline-functions"]), 34 tuple(BuildOption.noBoundsCheck, ["-fno-bounds-check"]), 35 tuple(BuildOption.optimize, ["-O3"]), 36 tuple(BuildOption.profile, ["-pg"]), 37 tuple(BuildOption.unittests, ["-funittest"]), 38 tuple(BuildOption.verbose, ["-fd-verbose"]), 39 tuple(BuildOption.ignoreUnknownPragmas, ["-fignore-unknown-pragmas"]), 40 tuple(BuildOption.syntaxOnly, ["-fsyntax-only"]), 41 tuple(BuildOption.warnings, ["-Wall"]), 42 tuple(BuildOption.warningsAsErrors, ["-Werror", "-Wall"]), 43 tuple(BuildOption.ignoreDeprecations, ["-Wno-deprecated"]), 44 tuple(BuildOption.deprecationWarnings, ["-Wdeprecated"]), 45 tuple(BuildOption.deprecationErrors, ["-Werror", "-Wdeprecated"]), 46 tuple(BuildOption.property, ["-fproperty"]), 47 //tuple(BuildOption.profileGC, ["-?"]), 48 49 tuple(BuildOption._docs, ["-fdoc-dir=docs"]), 50 tuple(BuildOption._ddox, ["-fXf=docs.json", "-fdoc-file=__dummy.html"]), 51 ]; 52 53 @property string name() const { return "gdc"; } 54 55 string determineVersion(string compiler_binary, string verboseOutput) 56 { 57 const result = execute([ 58 compiler_binary, 59 "-dumpfullversion", 60 "-dumpversion" 61 ]); 62 63 return result.status == 0 ? result.output : null; 64 } 65 66 BuildPlatform determinePlatform(ref BuildSettings settings, string compiler_binary, string arch_override) 67 { 68 string[] arch_flags; 69 switch (arch_override) { 70 default: throw new Exception("Unsupported architecture: "~arch_override); 71 case "": break; 72 case "arm": arch_flags = ["-marm"]; break; 73 case "arm_thumb": arch_flags = ["-mthumb"]; break; 74 case "x86": arch_flags = ["-m32"]; break; 75 case "x86_64": arch_flags = ["-m64"]; break; 76 } 77 settings.addDFlags(arch_flags); 78 79 return probePlatform( 80 compiler_binary, 81 arch_flags ~ ["-fsyntax-only", "-v"], 82 arch_override 83 ); 84 } 85 86 void prepareBuildSettings(ref BuildSettings settings, const scope ref BuildPlatform platform, BuildSetting fields = BuildSetting.all) const 87 { 88 enforceBuildRequirements(settings); 89 90 if (!(fields & BuildSetting.options)) { 91 foreach (t; s_options) 92 if (settings.options & t[0]) 93 settings.addDFlags(t[1]); 94 } 95 96 if (!(fields & BuildSetting.versions)) { 97 settings.addDFlags(settings.versions.map!(s => "-fversion="~s)().array()); 98 settings.versions = null; 99 } 100 101 if (!(fields & BuildSetting.debugVersions)) { 102 settings.addDFlags(settings.debugVersions.map!(s => "-fdebug="~s)().array()); 103 settings.debugVersions = null; 104 } 105 106 if (!(fields & BuildSetting.importPaths)) { 107 settings.addDFlags(settings.importPaths.map!(s => "-I"~s)().array()); 108 settings.importPaths = null; 109 } 110 111 if (!(fields & BuildSetting.stringImportPaths)) { 112 settings.addDFlags(settings.stringImportPaths.map!(s => "-J"~s)().array()); 113 settings.stringImportPaths = null; 114 } 115 116 if (!(fields & BuildSetting.sourceFiles)) { 117 settings.addDFlags(settings.sourceFiles); 118 settings.sourceFiles = null; 119 } 120 121 if (!(fields & BuildSetting.libs)) { 122 resolveLibs(settings, platform); 123 settings.addDFlags(settings.libs.map!(l => "-l"~l)().array()); 124 } 125 126 if (!(fields & BuildSetting.lflags)) { 127 settings.addDFlags(lflagsToDFlags(settings.lflags)); 128 settings.lflags = null; 129 } 130 131 if (settings.options & BuildOption.pic) 132 settings.addDFlags("-fPIC"); 133 134 assert(fields & BuildSetting.dflags); 135 assert(fields & BuildSetting.copyFiles); 136 } 137 138 void extractBuildOptions(ref BuildSettings settings) const 139 { 140 Appender!(string[]) newflags; 141 next_flag: foreach (f; settings.dflags) { 142 foreach (t; s_options) 143 if (t[1].canFind(f)) { 144 settings.options |= t[0]; 145 continue next_flag; 146 } 147 if (f.startsWith("-fversion=")) settings.addVersions(f[10 .. $]); 148 else if (f.startsWith("-fdebug=")) settings.addDebugVersions(f[8 .. $]); 149 else newflags ~= f; 150 } 151 settings.dflags = newflags.data; 152 } 153 154 string getTargetFileName(in BuildSettings settings, in BuildPlatform platform) 155 const { 156 assert(settings.targetName.length > 0, "No target name set."); 157 final switch (settings.targetType) { 158 case TargetType.autodetect: assert(false, "Configurations must have a concrete target type."); 159 case TargetType.none: return null; 160 case TargetType.sourceLibrary: return null; 161 case TargetType.executable: 162 if (platform.platform.canFind("windows")) 163 return settings.targetName ~ ".exe"; 164 else return settings.targetName.idup; 165 case TargetType.library: 166 case TargetType.staticLibrary: 167 return "lib" ~ settings.targetName ~ ".a"; 168 case TargetType.dynamicLibrary: 169 if (platform.platform.canFind("windows")) 170 return settings.targetName ~ ".dll"; 171 else if (platform.platform.canFind("darwin")) 172 return "lib" ~ settings.targetName ~ ".dylib"; 173 else return "lib" ~ settings.targetName ~ ".so"; 174 case TargetType.object: 175 if (platform.platform.canFind("windows")) 176 return settings.targetName ~ ".obj"; 177 else return settings.targetName ~ ".o"; 178 } 179 } 180 181 void setTarget(ref BuildSettings settings, in BuildPlatform platform, string tpath = null) const 182 { 183 final switch (settings.targetType) { 184 case TargetType.autodetect: assert(false, "Invalid target type: autodetect"); 185 case TargetType.none: assert(false, "Invalid target type: none"); 186 case TargetType.sourceLibrary: assert(false, "Invalid target type: sourceLibrary"); 187 case TargetType.executable: break; 188 case TargetType.library: 189 case TargetType.staticLibrary: 190 case TargetType.object: 191 settings.addDFlags("-c"); 192 break; 193 case TargetType.dynamicLibrary: 194 settings.addDFlags("-shared", "-fPIC"); 195 break; 196 } 197 198 if (tpath is null) 199 tpath = (NativePath(settings.targetPath) ~ getTargetFileName(settings, platform)).toNativeString(); 200 settings.addDFlags("-o", tpath); 201 } 202 203 void invoke(in BuildSettings settings, in BuildPlatform platform, void delegate(int, string) output_callback) 204 { 205 auto res_file = getTempFile("dub-build", ".rsp"); 206 std.file.write(res_file.toNativeString(), join(settings.dflags.map!(s => escape(s)), "\n")); 207 208 logDiagnostic("%s %s", platform.compilerBinary, join(cast(string[])settings.dflags, " ")); 209 string[string] env; 210 foreach (aa; [settings.environments, settings.buildEnvironments]) 211 foreach (k, v; aa) 212 env[k] = v; 213 invokeTool([platform.compilerBinary, "@"~res_file.toNativeString()], output_callback, env); 214 } 215 216 void invokeLinker(in BuildSettings settings, in BuildPlatform platform, string[] objects, void delegate(int, string) output_callback) 217 { 218 import std..string; 219 string[] args; 220 // As the user is supposed to call setTarget prior to invoke, -o target is already set. 221 if (settings.targetType == TargetType.staticLibrary || settings.targetType == TargetType.staticLibrary) { 222 auto tpath = extractTarget(settings.dflags); 223 assert(tpath !is null, "setTarget should be called before invoke"); 224 args = [ "ar", "rcs", tpath ] ~ objects; 225 } else { 226 args = platform.compilerBinary ~ objects ~ settings.sourceFiles ~ settings.lflags ~ settings.dflags.filter!(f => isLinkageFlag(f)).array; 227 if (platform.platform.canFind("linux")) 228 args ~= "-L--no-as-needed"; // avoids linker errors due to libraries being specified in the wrong order 229 } 230 logDiagnostic("%s", args.join(" ")); 231 string[string] env; 232 foreach (aa; [settings.environments, settings.buildEnvironments]) 233 foreach (k, v; aa) 234 env[k] = v; 235 invokeTool(args, output_callback, env); 236 } 237 238 string[] lflagsToDFlags(in string[] lflags) const 239 { 240 string[] dflags; 241 foreach( f; lflags ) 242 { 243 if ( f == "") { 244 continue; 245 } 246 dflags ~= "-Xlinker"; 247 dflags ~= f; 248 } 249 250 return dflags; 251 } 252 } 253 254 private string extractTarget(const string[] args) { auto i = args.countUntil("-o"); return i >= 0 ? args[i+1] : null; } 255 256 private bool isLinkageFlag(string flag) { 257 switch (flag) { 258 case "-c": 259 return false; 260 default: 261 return true; 262 } 263 } 264 265 private string escape(string str) 266 { 267 auto ret = appender!string(); 268 foreach (char ch; str) { 269 switch (ch) { 270 default: ret.put(ch); break; 271 case '\\': ret.put(`\\`); break; 272 case ' ': ret.put(`\ `); break; 273 } 274 } 275 return ret.data; 276 }