|
1 # Solaris GCC Toolchain discovery. |
|
2 # https://llvm.org/bugs/show_bug.cgi?id=24606 |
|
3 --- lib/Support/Host.cpp 2014-12-16 19:38:04.000000000 -0800 |
|
4 +++ lib/Support/Host.cpp 2016-02-09 09:59:19.281147309 -0800 |
|
5 @@ -39,6 +39,11 @@ |
|
6 #include <mach/machine.h> |
|
7 #endif |
|
8 |
|
9 +#if defined(sun) || defined(__sun) || defined(__sun__) |
|
10 +#include <cstring> |
|
11 +#include <kstat.h> |
|
12 +#endif |
|
13 + |
|
14 #define DEBUG_TYPE "host-detection" |
|
15 |
|
16 //===----------------------------------------------------------------------===// |
|
17 @@ -674,6 +679,43 @@ |
|
18 |
|
19 return "generic"; |
|
20 } |
|
21 +#elif ((defined(sun) || defined(__sun) || defined(__sun__)) && \ |
|
22 + (defined(sparc) || defined(__sparc) || defined(__sparc__))) |
|
23 +StringRef sys::getHostCPUName() { |
|
24 + kstat_ctl_t *KC = 0; |
|
25 + kstat_t *KSP = 0; |
|
26 + kstat_named_t *KNP = 0; |
|
27 + static char Buffer[256]; |
|
28 + static bool Init = false; |
|
29 + const char *Value; |
|
30 + |
|
31 + if (!Init) { |
|
32 + KC = kstat_open(); |
|
33 + if (KC) { |
|
34 + KSP = kstat_lookup(KC, "cpu_info", -1, "cpu_info0"); |
|
35 + kstat_read(KC, KSP, NULL); |
|
36 + KNP = reinterpret_cast<kstat_named_t*>(kstat_data_lookup(KSP, "brand")); |
|
37 + Value = (const char *) KNP->value.str.addr.ptr; |
|
38 + (void) std::sprintf(Buffer, "%s (", Value); |
|
39 + |
|
40 + KNP = |
|
41 + reinterpret_cast<kstat_named_t*>(kstat_data_lookup(KSP, "cpu_type")); |
|
42 + Value = (const char*) KNP->value.c; |
|
43 + (void) std::strcat(Buffer, Value); |
|
44 + (void) std::strcat(Buffer, ") "); |
|
45 + |
|
46 + KNP = |
|
47 + reinterpret_cast<kstat_named_t*>(kstat_data_lookup(KSP, |
|
48 + "implementation")); |
|
49 + Value = (const char*) KNP->value.str.addr.ptr; |
|
50 + (void) std::strcat(Buffer, Value); |
|
51 + Init = true; |
|
52 + kstat_close(KC); |
|
53 + } |
|
54 + } |
|
55 + |
|
56 + return Buffer; |
|
57 +} |
|
58 #else |
|
59 StringRef sys::getHostCPUName() { |
|
60 return "generic"; |
|
61 --- tools/clang/include/clang/Driver/Options.td Sat Jul 18 11:44:46 2015 |
|
62 +++ tools/clang/include/clang/Driver/Options.td Thu Aug 20 22:46:37 2015 |
|
63 @@ -1129,6 +1129,11 @@ |
|
64 def mthread_model : Separate<["-"], "mthread-model">, Group<m_Group>, Flags<[CC1Option]>, |
|
65 HelpText<"The thread model to use, e.g. posix, single (posix by default)">; |
|
66 |
|
67 +def mvis : Flag<["-"], "mvis">, Group<m_Group>; |
|
68 +def mvis2 : Flag<["-"], "mvis2">, Group<m_Group>; |
|
69 +def mvis3 : Flag<["-"], "mvis3">, Group<m_Group>; |
|
70 +def mimpure_text: Flag<["-"], "mimpure-text">, Group<m_Group>; |
|
71 + |
|
72 def mmmx : Flag<["-"], "mmmx">, Group<m_x86_Features_Group>; |
|
73 def mno_3dnowa : Flag<["-"], "mno-3dnowa">, Group<m_x86_Features_Group>; |
|
74 def mno_3dnow : Flag<["-"], "mno-3dnow">, Group<m_x86_Features_Group>; |
|
75 @@ -1690,6 +1695,7 @@ |
|
76 defm profile_use : BooleanFFlag<"profile-use">, Group<clang_ignored_gcc_optimization_f_Group>; |
|
77 def fprofile_use_EQ : Joined<["-"], "fprofile-use=">, Group<clang_ignored_gcc_optimization_f_Group>; |
|
78 def fuse_ld_EQ : Joined<["-"], "fuse-ld=">, Group<f_Group>; |
|
79 +def fuse_as_EQ : Joined<["-"], "fuse-as=">, Group<f_Group>; |
|
80 |
|
81 defm align_functions : BooleanFFlag<"align-functions">, Group<clang_ignored_gcc_optimization_f_Group>; |
|
82 def falign_functions_EQ : Joined<["-"], "falign-functions=">, Group<clang_ignored_gcc_optimization_f_Group>; |
|
83 --- tools/clang/lib/Frontend/InitHeaderSearch.cpp Thu Dec 4 16:22:48 2014 |
|
84 +++ tools/clang/lib/Frontend/InitHeaderSearch.cpp Fri Aug 21 23:23:27 2015 |
|
85 @@ -122,7 +122,7 @@ |
|
86 // Add the path with sysroot prepended, if desired and this is a system header |
|
87 // group. |
|
88 if (HasSysroot) { |
|
89 - SmallString<256> MappedPathStorage; |
|
90 + SmallString<PATH_MAX> MappedPathStorage; |
|
91 StringRef MappedPathStr = Path.toStringRef(MappedPathStorage); |
|
92 if (CanPrefixSysroot(MappedPathStr)) { |
|
93 AddUnmappedPath(IncludeSysroot + Path, Group, isFramework); |
|
94 @@ -138,7 +138,7 @@ |
|
95 assert(!Path.isTriviallyEmpty() && "can't handle empty path here"); |
|
96 |
|
97 FileManager &FM = Headers.getFileMgr(); |
|
98 - SmallString<256> MappedPathStorage; |
|
99 + SmallString<PATH_MAX> MappedPathStorage; |
|
100 StringRef MappedPathStr = Path.toStringRef(MappedPathStorage); |
|
101 |
|
102 // Compute the DirectoryLookup type. |
|
103 @@ -187,12 +187,16 @@ |
|
104 |
|
105 // Add the multilib dirs |
|
106 llvm::Triple::ArchType arch = triple.getArch(); |
|
107 - bool is64bit = arch == llvm::Triple::ppc64 || arch == llvm::Triple::x86_64; |
|
108 + bool is64bit = arch == llvm::Triple::ppc64 || arch == llvm::Triple::x86_64 || |
|
109 + arch == llvm::Triple::sparcv9; |
|
110 if (is64bit) |
|
111 AddPath(Base + "/" + ArchDir + "/" + Dir64, CXXSystem, false); |
|
112 else |
|
113 AddPath(Base + "/" + ArchDir + "/" + Dir32, CXXSystem, false); |
|
114 |
|
115 + // Add GCC's "C" include dir |
|
116 + AddPath(Base + "/include", CXXSystem, false); |
|
117 + |
|
118 // Add the backward dir |
|
119 AddPath(Base + "/backward", CXXSystem, false); |
|
120 } |
|
121 @@ -442,8 +446,7 @@ |
|
122 "", "", "", triple); |
|
123 break; |
|
124 case llvm::Triple::Solaris: |
|
125 - AddGnuCPlusPlusIncludePaths("/usr/gcc/4.5/include/c++/4.5.2/", |
|
126 - "i386-pc-solaris2.11", "", "", triple); |
|
127 + // All of this is handled in the driver. |
|
128 break; |
|
129 default: |
|
130 break; |
|
131 @@ -462,6 +465,7 @@ |
|
132 break; // Everything else continues to use this routine's logic. |
|
133 |
|
134 case llvm::Triple::Linux: |
|
135 + case llvm::Triple::Solaris: |
|
136 return; |
|
137 |
|
138 case llvm::Triple::Win32: |
|
139 @@ -484,7 +488,7 @@ |
|
140 // Remove clang from foo/lib/clang |
|
141 StringRef Lib = llvm::sys::path::parent_path(NoVer); |
|
142 // Remove lib from foo/lib |
|
143 - SmallString<128> P = llvm::sys::path::parent_path(Lib); |
|
144 + SmallString<PATH_MAX> P = llvm::sys::path::parent_path(Lib); |
|
145 |
|
146 // Get foo/include/c++/v1 |
|
147 llvm::sys::path::append(P, "include", "c++", "v1"); |
|
148 @@ -491,10 +495,6 @@ |
|
149 AddUnmappedPath(P.str(), CXXSystem, false); |
|
150 } |
|
151 } |
|
152 - // On Solaris, include the support directory for things like xlocale and |
|
153 - // fudged system headers. |
|
154 - if (triple.getOS() == llvm::Triple::Solaris) |
|
155 - AddPath("/usr/include/c++/v1/support/solaris", CXXSystem, false); |
|
156 |
|
157 AddPath("/usr/include/c++/v1", CXXSystem, false); |
|
158 } else { |
|
159 --- tools/clang/lib/Driver/Tools.h Wed Jan 28 15:52:21 2015 |
|
160 +++ tools/clang/lib/Driver/Tools.h Thu Aug 20 22:46:37 2015 |
|
161 @@ -529,6 +529,9 @@ |
|
162 |
|
163 bool hasIntegratedCPP() const override { return false; } |
|
164 |
|
165 + void RenderExtraToolArgs(const JobAction &JA, |
|
166 + ArgStringList &CmdArgs) const; |
|
167 + |
|
168 void ConstructJob(Compilation &C, const JobAction &JA, |
|
169 const InputInfo &Output, const InputInfoList &Inputs, |
|
170 const llvm::opt::ArgList &TCArgs, |
|
171 @@ -541,6 +544,9 @@ |
|
172 bool hasIntegratedCPP() const override { return false; } |
|
173 bool isLinkJob() const override { return true; } |
|
174 |
|
175 + void RenderExtraToolArgs(const JobAction &JA, |
|
176 + ArgStringList &CmdArgs) const; |
|
177 + |
|
178 void ConstructJob(Compilation &C, const JobAction &JA, |
|
179 const InputInfo &Output, const InputInfoList &Inputs, |
|
180 const llvm::opt::ArgList &TCArgs, |
|
181 --- tools/clang/lib/Driver/Tools.cpp Sat Jul 18 11:44:46 2015 |
|
182 +++ tools/clang/lib/Driver/Tools.cpp Sat Aug 22 17:26:16 2015 |
|
183 @@ -60,6 +60,12 @@ |
|
184 } |
|
185 } |
|
186 |
|
187 +static void AddLibgcc(const llvm::Triple &Triple, const Driver &D, |
|
188 + ArgStringList &CmdArgs, const ArgList &Args); |
|
189 + |
|
190 +static void AddLibgcc(const Driver &D, ArgStringList &CmdArgs, |
|
191 + const ArgList &Args, const std::string& Exec); |
|
192 + |
|
193 /// CheckPreprocessingOptions - Perform some validation of preprocessing |
|
194 /// arguments that is shared with gcc. |
|
195 static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) { |
|
196 @@ -1360,14 +1366,30 @@ |
|
197 return ""; |
|
198 } |
|
199 |
|
200 +static const char *getSparcTargetCPU(const ArgList &Args, |
|
201 + const llvm::Triple &Triple); |
|
202 + |
|
203 +static const char *getSparcTargetCPUFeature(const char* CPU, |
|
204 + const ArgList &Args, |
|
205 + const llvm::Triple &Triple); |
|
206 + |
|
207 static void getSparcTargetFeatures(const ArgList &Args, |
|
208 - std::vector<const char *> &Features) { |
|
209 - bool SoftFloatABI = true; |
|
210 + std::vector<const char *> &Features, |
|
211 + const llvm::Triple &Triple) { |
|
212 + bool SoftFloatABI; |
|
213 + |
|
214 + if ((Triple.getOS() == llvm::Triple::Solaris) || |
|
215 + (Triple.getOS() == llvm::Triple::Linux)) |
|
216 + SoftFloatABI = false; |
|
217 + else |
|
218 + SoftFloatABI = true; |
|
219 + |
|
220 if (Arg *A = |
|
221 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) { |
|
222 if (A->getOption().matches(options::OPT_mhard_float)) |
|
223 SoftFloatABI = false; |
|
224 } |
|
225 + |
|
226 if (SoftFloatABI) |
|
227 Features.push_back("+soft-float"); |
|
228 } |
|
229 @@ -1375,17 +1397,31 @@ |
|
230 void Clang::AddSparcTargetArgs(const ArgList &Args, |
|
231 ArgStringList &CmdArgs) const { |
|
232 const Driver &D = getToolChain().getDriver(); |
|
233 + const llvm::Triple &T = getToolChain().getTriple(); |
|
234 |
|
235 // Select the float ABI as determined by -msoft-float and -mhard-float. |
|
236 + // There is no support for soft-float ABI in Solaris. |
|
237 StringRef FloatABI; |
|
238 if (Arg *A = Args.getLastArg(options::OPT_msoft_float, |
|
239 options::OPT_mhard_float)) { |
|
240 - if (A->getOption().matches(options::OPT_msoft_float)) |
|
241 + if (A->getOption().matches(options::OPT_msoft_float)) { |
|
242 + if ((T.getOS() == llvm::Triple::Solaris) || |
|
243 + (T.getOS() == llvm::Triple::Linux)) { |
|
244 + D.Diag(diag::warn_drv_clang_unsupported) << "-msoft-float"; |
|
245 + D.Diag(diag::warn_drv_overriding_flag_option) << |
|
246 + "-msoft-float" << "-mhard-float"; |
|
247 + FloatABI = "hard"; |
|
248 + } else { |
|
249 FloatABI = "soft"; |
|
250 - else if (A->getOption().matches(options::OPT_mhard_float)) |
|
251 + } |
|
252 + } else if (A->getOption().matches(options::OPT_mhard_float)) |
|
253 FloatABI = "hard"; |
|
254 } |
|
255 |
|
256 + if (((T.getOS() == llvm::Triple::Solaris) || |
|
257 + (T.getOS() == llvm::Triple::Linux)) && FloatABI.empty()) |
|
258 + FloatABI = "hard"; |
|
259 + |
|
260 // If unspecified, choose the default based on the platform. |
|
261 if (FloatABI.empty()) { |
|
262 // Assume "soft", but warn the user we are guessing. |
|
263 @@ -1400,10 +1436,93 @@ |
|
264 CmdArgs.push_back("-msoft-float"); |
|
265 } else { |
|
266 assert(FloatABI == "hard" && "Invalid float abi!"); |
|
267 - CmdArgs.push_back("-mhard-float"); |
|
268 } |
|
269 + |
|
270 + std::string Feature; |
|
271 + if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) { |
|
272 + Feature = "-march="; |
|
273 + Feature += A->getValue(); |
|
274 + CmdArgs.push_back(Args.MakeArgString("-target-feature")); |
|
275 + CmdArgs.push_back(Args.MakeArgString(Feature.c_str())); |
|
276 } |
|
277 |
|
278 + if (Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) { |
|
279 + Feature = "-mtune="; |
|
280 + Feature += A->getValue(); |
|
281 + CmdArgs.push_back(Args.MakeArgString("-target-feature")); |
|
282 + CmdArgs.push_back(Args.MakeArgString(Feature.c_str())); |
|
283 + } |
|
284 + |
|
285 + if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { |
|
286 + Feature = "-mcpu="; |
|
287 + Feature += A->getValue(); |
|
288 + CmdArgs.push_back(Args.MakeArgString("-target-feature")); |
|
289 + CmdArgs.push_back(Args.MakeArgString(Feature.c_str())); |
|
290 + } |
|
291 +} |
|
292 + |
|
293 +static const char *getSparcTargetCPU(const ArgList &Args, |
|
294 + const llvm::Triple &Triple) { |
|
295 + StringRef V; |
|
296 + |
|
297 + if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) { |
|
298 + V = A->getValue(); |
|
299 + switch (Triple.getOS()) { |
|
300 + case llvm::Triple::Solaris: |
|
301 + case llvm::Triple::Linux: |
|
302 + if (V == "v8plus" || V == "v8plusa" || |
|
303 + V == "v8plusb" || V == "v9" || |
|
304 + V == "v9a" || V == "v9b" || |
|
305 + V == "sparcmaf" || V == "sparc4" ) |
|
306 + return Args.MakeArgString(V); |
|
307 + break; |
|
308 + default: |
|
309 + return Args.MakeArgString("v8plusa"); |
|
310 + break; |
|
311 + } |
|
312 + } |
|
313 + |
|
314 + if (Arg *AA = Args.getLastArg(options::OPT_m64)) |
|
315 + return "v9a"; |
|
316 + |
|
317 + return "v8plusa"; |
|
318 +} |
|
319 + |
|
320 +static const char *getSparcTargetCPUFeature(const char* CPU, |
|
321 + const ArgList &Args, |
|
322 + const llvm::Triple &Triple) { |
|
323 + StringRef V; |
|
324 + if (Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) { |
|
325 + V = A->getValue(); |
|
326 + |
|
327 + if (V.empty()) |
|
328 + if (Arg *AA = Args.getLastArg(options::OPT_m64)) |
|
329 + return "vis"; |
|
330 + |
|
331 + if (V == "ultrasparc" || V == "ultrasparc2" || |
|
332 + V == "ultrasparc3" || V == "sparcmaf" || V == "sparc4" ) |
|
333 + return Args.MakeArgString(A->getValue()); |
|
334 + } |
|
335 + |
|
336 + if (!CPU) |
|
337 + return 0; |
|
338 + |
|
339 + std::string C = CPU; |
|
340 + |
|
341 + if (C == "v8plus" || C == "v9") |
|
342 + return ""; |
|
343 + |
|
344 + if (C == "v8plusa" || C == "v9a") |
|
345 + return "vis1"; |
|
346 + else if (C == "v8plusb" || C == "v9b") |
|
347 + return "vis2"; |
|
348 + else if (C == "sparcmaf" || C == "sparc4") |
|
349 + return "vis3"; |
|
350 + |
|
351 + return 0; |
|
352 +} |
|
353 + |
|
354 + |
|
355 static const char *getSystemZTargetCPU(const ArgList &Args) { |
|
356 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) |
|
357 return A->getValue(); |
|
358 @@ -1872,7 +1991,7 @@ |
|
359 break; |
|
360 case llvm::Triple::sparc: |
|
361 case llvm::Triple::sparcv9: |
|
362 - getSparcTargetFeatures(Args, Features); |
|
363 + getSparcTargetFeatures(Args, Features, Triple); |
|
364 break; |
|
365 case llvm::Triple::aarch64: |
|
366 case llvm::Triple::aarch64_be: |
|
367 @@ -2695,6 +2814,23 @@ |
|
368 } |
|
369 } |
|
370 |
|
371 + // Solaris-specific defaults for PIE |
|
372 + if (getToolChain().getTriple().getOS() == llvm::Triple::Solaris) { |
|
373 + switch (getToolChain().getTriple().getArch()) { |
|
374 + case llvm::Triple::x86: |
|
375 + IsPICLevelTwo = false; // "-fpie" |
|
376 + break; |
|
377 + case llvm::Triple::sparc: |
|
378 + case llvm::Triple::x86_64: |
|
379 + case llvm::Triple::sparcv9: |
|
380 + IsPICLevelTwo = true; // "-fPIE" |
|
381 + break; |
|
382 + |
|
383 + default: |
|
384 + break; |
|
385 + } |
|
386 + } |
|
387 + |
|
388 // For the PIC and PIE flag options, this logic is different from the |
|
389 // legacy logic in very old versions of GCC, as that logic was just |
|
390 // a bug no one had ever fixed. This logic is both more rational and |
|
391 @@ -2740,6 +2876,47 @@ |
|
392 if (Args.hasArg(options::OPT_static)) |
|
393 PIC = PIE = false; |
|
394 |
|
395 + if (Triple.getOS() == llvm::Triple::Solaris) { |
|
396 + if (Arg *A = Args.getLastArg(options::OPT_shared)) { |
|
397 + PIC = true; |
|
398 + PIE = false; |
|
399 + CmdArgs.push_back("-mrelocation-model"); |
|
400 + CmdArgs.push_back("pic"); |
|
401 + if (IsPICLevelTwo) { |
|
402 + CmdArgs.push_back("-pic-level"); |
|
403 + CmdArgs.push_back("2"); |
|
404 + } |
|
405 + } else if (PIC) { |
|
406 + PIC = true; |
|
407 + PIE = false; |
|
408 + CmdArgs.push_back("-mrelocation-model"); |
|
409 + CmdArgs.push_back("pic"); |
|
410 + if (IsPICLevelTwo) { |
|
411 + CmdArgs.push_back("-pic-level"); |
|
412 + CmdArgs.push_back("2"); |
|
413 + } |
|
414 + } else if (PIE) { |
|
415 + PIC = PIE = true; |
|
416 + CmdArgs.push_back("-mrelocation-model"); |
|
417 + CmdArgs.push_back("pic"); |
|
418 + if (IsPICLevelTwo) { |
|
419 + CmdArgs.push_back("-pie-level"); |
|
420 + CmdArgs.push_back("2"); |
|
421 + } |
|
422 + } else if (Args.hasArg(options::OPT_static)) { |
|
423 + // Solaris doesn't to static relocations. |
|
424 + PIC = PIE = false; |
|
425 + CmdArgs.push_back("-mrelocation-model"); |
|
426 + CmdArgs.push_back("dynamic-no-pic"); |
|
427 + } else { |
|
428 + // This is a Solaris non-PIE executable. |
|
429 + // Solaris doesn't to static relocations. |
|
430 + PIC = PIE = false; |
|
431 + CmdArgs.push_back("-mrelocation-model"); |
|
432 + CmdArgs.push_back("dynamic-no-pic"); |
|
433 + } |
|
434 + } |
|
435 + |
|
436 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) { |
|
437 // This is a very special mode. It trumps the other modes, almost no one |
|
438 // uses it, and it isn't even valid on any OS but Darwin. |
|
439 @@ -2762,6 +2939,8 @@ |
|
440 } else { |
|
441 // Currently, LLVM only knows about PIC vs. static; the PIE differences are |
|
442 // handled in Clang's IRGen by the -pie-level flag. |
|
443 + // Solaris already took care of PIC/PIE/non-PIC above. |
|
444 + if (Triple.getOS() != llvm::Triple::Solaris) { |
|
445 CmdArgs.push_back("-mrelocation-model"); |
|
446 CmdArgs.push_back(PIC ? "pic" : "static"); |
|
447 |
|
448 @@ -2774,6 +2953,7 @@ |
|
449 } |
|
450 } |
|
451 } |
|
452 + } |
|
453 |
|
454 CmdArgs.push_back("-mthread-model"); |
|
455 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) |
|
456 @@ -3180,12 +3360,13 @@ |
|
457 // FIXME: we should support specifying dwarf version with |
|
458 // -gline-tables-only. |
|
459 CmdArgs.push_back("-gline-tables-only"); |
|
460 - // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris. |
|
461 + // Default is dwarf-2 for Darwin, OpenBSD and FreeBSD. |
|
462 const llvm::Triple &Triple = getToolChain().getTriple(); |
|
463 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD || |
|
464 - Triple.getOS() == llvm::Triple::FreeBSD || |
|
465 - Triple.getOS() == llvm::Triple::Solaris) |
|
466 + Triple.getOS() == llvm::Triple::FreeBSD) |
|
467 CmdArgs.push_back("-gdwarf-2"); |
|
468 + else if (Triple.getOS() == llvm::Triple::Solaris) |
|
469 + CmdArgs.push_back("-gdwarf-4"); |
|
470 } else if (A->getOption().matches(options::OPT_gdwarf_2)) |
|
471 CmdArgs.push_back("-gdwarf-2"); |
|
472 else if (A->getOption().matches(options::OPT_gdwarf_3)) |
|
473 @@ -3194,12 +3375,13 @@ |
|
474 CmdArgs.push_back("-gdwarf-4"); |
|
475 else if (!A->getOption().matches(options::OPT_g0) && |
|
476 !A->getOption().matches(options::OPT_ggdb0)) { |
|
477 - // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris. |
|
478 + // Default is dwarf-2 for Darwin, OpenBSD and FreeBSD. |
|
479 const llvm::Triple &Triple = getToolChain().getTriple(); |
|
480 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD || |
|
481 - Triple.getOS() == llvm::Triple::FreeBSD || |
|
482 - Triple.getOS() == llvm::Triple::Solaris) |
|
483 + Triple.getOS() == llvm::Triple::FreeBSD) |
|
484 CmdArgs.push_back("-gdwarf-2"); |
|
485 + else if (Triple.getOS() == llvm::Triple::Solaris) |
|
486 + CmdArgs.push_back("-gdwarf-4"); |
|
487 else |
|
488 CmdArgs.push_back("-g"); |
|
489 } |
|
490 @@ -3594,6 +3776,7 @@ |
|
491 // If -fmessage-length=N was not specified, determine whether this is a |
|
492 // terminal and, if so, implicitly define -fmessage-length appropriately. |
|
493 unsigned N = llvm::sys::Process::StandardErrColumns(); |
|
494 + if (N == 0) N = 72U; |
|
495 CmdArgs.push_back(Args.MakeArgString(Twine(N))); |
|
496 } |
|
497 |
|
498 @@ -3735,6 +3918,7 @@ |
|
499 CmdArgs.push_back("-backend-option"); |
|
500 CmdArgs.push_back("-force-align-stack"); |
|
501 } |
|
502 + |
|
503 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign, |
|
504 false)) { |
|
505 CmdArgs.push_back(Args.MakeArgString("-mstackrealign")); |
|
506 @@ -3743,6 +3927,10 @@ |
|
507 if (Args.hasArg(options::OPT_mstack_alignment)) { |
|
508 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment); |
|
509 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment)); |
|
510 + } else { |
|
511 + if ((getToolChain().getTriple().getArch() == llvm::Triple::sparc) || |
|
512 + (getToolChain().getTriple().getArch() == llvm::Triple::sparcv9)) |
|
513 + CmdArgs.push_back("-mstack-alignment=16"); |
|
514 } |
|
515 |
|
516 if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 || |
|
517 @@ -6049,6 +6237,10 @@ |
|
518 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); |
|
519 } |
|
520 |
|
521 +void solaris::Assemble::RenderExtraToolArgs(const JobAction &JA, |
|
522 + ArgStringList &CmdArgs) const { |
|
523 +} |
|
524 + |
|
525 void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA, |
|
526 const InputInfo &Output, |
|
527 const InputInfoList &Inputs, |
|
528 @@ -6055,61 +6247,321 @@ |
|
529 const ArgList &Args, |
|
530 const char *LinkingOutput) const { |
|
531 claimNoWarnArgs(Args); |
|
532 + |
|
533 + const toolchains::Solaris &TC = |
|
534 + static_cast<const toolchains::Solaris&>(getToolChain()); |
|
535 + |
|
536 + if (!TC.isValid()) { |
|
537 + llvm::errs() << "Invalid GCC installation!\n"; |
|
538 + return; |
|
539 + } |
|
540 + |
|
541 + const llvm::Triple &TT = TC.getTriple(); |
|
542 + const Driver &D = TC.getDriver(); |
|
543 + llvm::Triple::ArchType Arch = TT.getArch(); |
|
544 + StringRef Assembler = TC.getAssembler(); |
|
545 + bool m32 = true; |
|
546 + |
|
547 + std::string march; |
|
548 + std::string mtune; |
|
549 + std::string mcpu; |
|
550 + |
|
551 ArgStringList CmdArgs; |
|
552 |
|
553 - Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, |
|
554 - options::OPT_Xassembler); |
|
555 + if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) |
|
556 + march = A->getValue(); |
|
557 + else |
|
558 + march = TC.getMArch(); |
|
559 |
|
560 + if (Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) |
|
561 + mtune = A->getValue(); |
|
562 + else |
|
563 + mtune = TC.getMTune(); |
|
564 + |
|
565 + if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) |
|
566 + mcpu = A->getValue(); |
|
567 + else |
|
568 + mcpu = TC.getMCpu(); |
|
569 + |
|
570 + if (Arg *A = Args.getLastArg(options::OPT_m64)) |
|
571 + m32 = false; |
|
572 + |
|
573 + if (Args.hasArg(options::OPT_v)) |
|
574 + CmdArgs.push_back("-V"); |
|
575 + |
|
576 + switch (Arch) { |
|
577 + case llvm::Triple::x86: |
|
578 + case llvm::Triple::x86_64: |
|
579 + if (m32) |
|
580 + CmdArgs.push_back("--32"); |
|
581 + else |
|
582 + CmdArgs.push_back("--64"); |
|
583 + break; |
|
584 + case llvm::Triple::sparc: |
|
585 + case llvm::Triple::sparcv9: |
|
586 + if (m32) { |
|
587 + CmdArgs.push_back("-32"); |
|
588 + march="v8plusa"; |
|
589 + mcpu="v8plusa"; |
|
590 + } else { |
|
591 + CmdArgs.push_back("-64"); |
|
592 + march="v9a"; |
|
593 + mcpu="v9a"; |
|
594 + } |
|
595 + break; |
|
596 + default: |
|
597 + D.Diag(diag::err_target_unsupported_arch) << TT.getArchName() |
|
598 + << TT.getTriple(); |
|
599 + break; |
|
600 + } |
|
601 + |
|
602 + std::string xarch; |
|
603 + |
|
604 + switch (Arch) { |
|
605 + case llvm::Triple::sparc: |
|
606 + case llvm::Triple::sparcv9: |
|
607 + if (!march.empty()) { |
|
608 + xarch = "-xarch="; |
|
609 + xarch += march; |
|
610 + CmdArgs.push_back(Args.MakeArgString(xarch.c_str())); |
|
611 + } else if (!mtune.empty()) { |
|
612 + xarch = "-xarch="; |
|
613 + xarch += mtune; |
|
614 + CmdArgs.push_back(Args.MakeArgString(xarch.c_str())); |
|
615 + } else if (!mcpu.empty()) { |
|
616 + xarch = "-xarch="; |
|
617 + xarch += mcpu; |
|
618 + CmdArgs.push_back(Args.MakeArgString(xarch.c_str())); |
|
619 + } |
|
620 + |
|
621 + addAssemblerKPIC(Args, CmdArgs); |
|
622 + |
|
623 + if (Args.hasArg(options::OPT_mstrict_align)) |
|
624 + CmdArgs.push_back("--enforce-aligned-data"); |
|
625 + break; |
|
626 + case llvm::Triple::x86: |
|
627 + case llvm::Triple::x86_64: |
|
628 + if (!march.empty()) { |
|
629 + xarch = "-mtune="; |
|
630 + xarch += march; |
|
631 + CmdArgs.push_back(Args.MakeArgString(xarch.c_str())); |
|
632 + } else if (!mtune.empty()) { |
|
633 + xarch = "-mtune="; |
|
634 + xarch += mtune; |
|
635 + CmdArgs.push_back(Args.MakeArgString(xarch.c_str())); |
|
636 + } |
|
637 + if (!mcpu.empty()) { |
|
638 + xarch = "-march="; |
|
639 + xarch += mcpu; |
|
640 + CmdArgs.push_back(Args.MakeArgString(xarch.c_str())); |
|
641 + } |
|
642 + break; |
|
643 + default: |
|
644 + D.Diag(diag::err_target_unsupported_arch) << TT.getArchName() |
|
645 + << TT.getTriple(); |
|
646 + break; |
|
647 + } |
|
648 + |
|
649 + if (Args.hasArg(options::OPT_g_Flag) || Args.hasArg(options::OPT_g0) || |
|
650 + Args.hasArg(options::OPT_g1) || Args.hasArg(options::OPT_g2) || |
|
651 + Args.hasArg(options::OPT_g3)) |
|
652 + CmdArgs.push_back("--gen-debug"); |
|
653 + |
|
654 + if (Output.isFilename()) { |
|
655 CmdArgs.push_back("-o"); |
|
656 CmdArgs.push_back(Output.getFilename()); |
|
657 + } else { |
|
658 + D.Diag(diag::err_drv_invalid_gcc_output_type) << "<unspecified>"; |
|
659 + CmdArgs.push_back("-fsyntax-only"); |
|
660 + } |
|
661 |
|
662 - for (const auto &II : Inputs) |
|
663 + RenderExtraToolArgs(JA, CmdArgs); |
|
664 + |
|
665 + Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, |
|
666 + options::OPT_Xassembler); |
|
667 + |
|
668 + for (const auto &II : Inputs) { |
|
669 + if (II.getType() == types::TY_LLVM_IR || |
|
670 + II.getType() == types::TY_LTO_IR || |
|
671 + II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC) |
|
672 + D.Diag(clang::diag::err_drv_no_linker_llvm_support) |
|
673 + << getToolChain().getTripleString(); |
|
674 + else if (II.getType() == types::TY_AST) |
|
675 + D.Diag(clang::diag::err_drv_no_ast_support) |
|
676 + << getToolChain().getTripleString(); |
|
677 + else if (II.getType() == types::TY_ModuleFile) |
|
678 + D.Diag(diag::err_drv_no_module_support) |
|
679 + << getToolChain().getTripleString(); |
|
680 + |
|
681 + if (II.isFilename()) |
|
682 CmdArgs.push_back(II.getFilename()); |
|
683 + else |
|
684 + II.getInputArg().render(Args, CmdArgs); |
|
685 + } |
|
686 |
|
687 - const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as")); |
|
688 - C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); |
|
689 + C.addCommand(llvm::make_unique<Command>(JA, *this, |
|
690 + Args.MakeArgString(Assembler), |
|
691 + CmdArgs)); |
|
692 } |
|
693 |
|
694 + |
|
695 +void solaris::Link::RenderExtraToolArgs(const JobAction &JA, |
|
696 + ArgStringList &CmdArgs) const { |
|
697 +} |
|
698 + |
|
699 void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA, |
|
700 const InputInfo &Output, |
|
701 const InputInfoList &Inputs, |
|
702 const ArgList &Args, |
|
703 const char *LinkingOutput) const { |
|
704 - // FIXME: Find a real GCC, don't hard-code versions here |
|
705 - std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/"; |
|
706 - const llvm::Triple &T = getToolChain().getTriple(); |
|
707 - std::string LibPath = "/usr/lib/"; |
|
708 + const toolchains::Solaris& TC = |
|
709 + static_cast<const toolchains::Solaris&>(getToolChain()); |
|
710 + |
|
711 + if (!TC.isValid()) { |
|
712 + llvm::errs() << "Invalid GCC installation!\n"; |
|
713 + return; |
|
714 + } |
|
715 + |
|
716 + const llvm::Triple &T = TC.getTriple(); |
|
717 + const Driver &D = TC.getDriver(); |
|
718 llvm::Triple::ArchType Arch = T.getArch(); |
|
719 + bool m32 = true; |
|
720 + StringRef Linker = TC.getLinker(); |
|
721 + |
|
722 + if (Arg *A = Args.getLastArg(options::OPT_m64)) |
|
723 + m32 = false; |
|
724 + |
|
725 + std::string GCCLibPath; |
|
726 + std::string YPPath; |
|
727 + GCCLibPath += "/lib/gcc/"; |
|
728 + std::string LibPath = "/usr/lib/"; |
|
729 + std::string ShortLibPath = "/lib/"; |
|
730 + std::string ClangLibPath; |
|
731 + const char* moption; |
|
732 + |
|
733 switch (Arch) { |
|
734 case llvm::Triple::x86: |
|
735 - GCCLibPath += |
|
736 - ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/"; |
|
737 + if (m32) { |
|
738 + GCCLibPath = TC.getGCCInternalLibDir().str(); |
|
739 + GCCLibPath += "/"; |
|
740 + moption = "-32"; |
|
741 + YPPath = "/lib:/usr/lib"; |
|
742 + ClangLibPath = "/usr/lib/clang/"; |
|
743 + } else { |
|
744 + GCCLibPath = TC.getGCCInternalMultiLibDir().str(); |
|
745 + GCCLibPath += "/"; |
|
746 + LibPath += "amd64/"; |
|
747 + ShortLibPath += "amd64/"; |
|
748 + moption = "-64"; |
|
749 + YPPath = "/lib/amd64:/usr/lib/amd64"; |
|
750 + ClangLibPath = "/usr/lib/clang/amd64/"; |
|
751 + } |
|
752 break; |
|
753 + case llvm::Triple::sparc: |
|
754 + if (m32) { |
|
755 + GCCLibPath = TC.getGCCInternalLibDir().str(); |
|
756 + GCCLibPath += "/"; |
|
757 + moption = "-32"; |
|
758 + YPPath = "/lib:/usr/lib"; |
|
759 + ClangLibPath = "/usr/lib/clang/"; |
|
760 + } else { |
|
761 + GCCLibPath = TC.getGCCInternalMultiLibDir().str(); |
|
762 + GCCLibPath += "/"; |
|
763 + LibPath += "sparcv9/"; |
|
764 + ShortLibPath += "sparcv9/"; |
|
765 + moption = "-64"; |
|
766 + YPPath = "/lib/sparcv9:/usr/lib/sparcv9"; |
|
767 + ClangLibPath = "/usr/lib/clang/sparcv9/"; |
|
768 + } |
|
769 + break; |
|
770 case llvm::Triple::x86_64: |
|
771 - GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str(); |
|
772 - GCCLibPath += "/4.5.2/amd64/"; |
|
773 + if (m32) { |
|
774 + GCCLibPath = TC.getGCCInternalMultiLibDir().str(); |
|
775 + GCCLibPath += "/"; |
|
776 + moption = "-32"; |
|
777 + YPPath = "/lib:/usr/lib"; |
|
778 + ClangLibPath = "/usr/lib/clang/"; |
|
779 + } else { |
|
780 + GCCLibPath = TC.getGCCInternalLibDir().str(); |
|
781 + GCCLibPath += "/"; |
|
782 LibPath += "amd64/"; |
|
783 + ShortLibPath += "amd64/"; |
|
784 + moption = "-64"; |
|
785 + YPPath = "/lib/amd64:/usr/lib/amd64"; |
|
786 + ClangLibPath = "/usr/lib/clang/amd64/"; |
|
787 + } |
|
788 break; |
|
789 + case llvm::Triple::sparcv9: |
|
790 + if (m32) { |
|
791 + GCCLibPath = TC.getGCCInternalMultiLibDir().str(); |
|
792 + GCCLibPath += "/"; |
|
793 + moption = "-32"; |
|
794 + YPPath = "/lib:/usr/lib"; |
|
795 + ClangLibPath = "/usr/lib/clang/"; |
|
796 + } else { |
|
797 + GCCLibPath = TC.getGCCInternalLibDir().str(); |
|
798 + GCCLibPath += "/"; |
|
799 + LibPath += "sparcv9/"; |
|
800 + ShortLibPath += "sparcv9/"; |
|
801 + moption = "-64"; |
|
802 + YPPath = "/lib/sparcv9:/usr/lib/sparcv9"; |
|
803 + ClangLibPath = "/usr/lib/clang/sparcv9/"; |
|
804 + } |
|
805 + break; |
|
806 default: |
|
807 - llvm_unreachable("Unsupported architecture"); |
|
808 + D.Diag(diag::err_target_unsupported_arch) << T.getArchName() |
|
809 + << T.getTriple(); |
|
810 + break; |
|
811 } |
|
812 |
|
813 ArgStringList CmdArgs; |
|
814 |
|
815 - // Demangle C++ names in errors |
|
816 - CmdArgs.push_back("-C"); |
|
817 + CmdArgs.push_back(Args.MakeArgString("-zignore")); |
|
818 |
|
819 - if ((!Args.hasArg(options::OPT_nostdlib)) && |
|
820 - (!Args.hasArg(options::OPT_shared))) { |
|
821 - CmdArgs.push_back("-e"); |
|
822 - CmdArgs.push_back("_start"); |
|
823 + Arg *PIEArg = Args.getLastArg(options::OPT_fPIE, options::OPT_fpie); |
|
824 + if (PIEArg) { |
|
825 + if (PIEArg->getOption().matches(options::OPT_fPIE) || |
|
826 + PIEArg->getOption().matches(options::OPT_fpie)) { |
|
827 + CmdArgs.push_back(Args.MakeArgString("-Qy")); |
|
828 + CmdArgs.push_back(Args.MakeArgString("-zdirect")); |
|
829 + CmdArgs.push_back(Args.MakeArgString("-ztextwarn")); |
|
830 + CmdArgs.push_back(Args.MakeArgString("-ztype=pie")); |
|
831 + CmdArgs.push_back(Args.MakeArgString("-zaslr=enable")); |
|
832 } |
|
833 + } |
|
834 |
|
835 + // Silence warning for "-g: argument not used during compilation |
|
836 + Args.ClaimAllArgs(options::OPT_g_Group); |
|
837 + |
|
838 + // Language options |
|
839 + Args.ClaimAllArgs(options::OPT_emit_llvm); |
|
840 + Args.ClaimAllArgs(options::OPT_w); |
|
841 + |
|
842 + if (Args.hasArg(options::OPT_s)) |
|
843 + CmdArgs.push_back("-s"); |
|
844 + |
|
845 + const std::vector<std::string> &ExtraOpts = TC.getExtraOpts(); |
|
846 + |
|
847 + // Handle extra options |
|
848 + if (ExtraOpts.size()) { |
|
849 + for (std::vector<std::string>::const_iterator I = ExtraOpts.begin(), |
|
850 + E = ExtraOpts.end(); I != E; ++I) |
|
851 + CmdArgs.push_back((*I).c_str()); |
|
852 + } |
|
853 + |
|
854 + // Demangle C++ names |
|
855 + if (Linker == "/usr/gnu/bin/ld.bfd" || Linker == "/usr/gnu/bin/ld.gold" || |
|
856 + Linker == "/usr/gnu/bin/ld" || Linker == "/usr/bin/gld") |
|
857 + CmdArgs.push_back("--demangle"); |
|
858 + else if (Linker == "/usr/bin/ld") |
|
859 + CmdArgs.push_back("-C"); |
|
860 + |
|
861 if (Args.hasArg(options::OPT_static)) { |
|
862 CmdArgs.push_back("-Bstatic"); |
|
863 CmdArgs.push_back("-dn"); |
|
864 } else { |
|
865 CmdArgs.push_back("-Bdynamic"); |
|
866 + CmdArgs.push_back("-dy"); |
|
867 if (Args.hasArg(options::OPT_shared)) { |
|
868 CmdArgs.push_back("-shared"); |
|
869 } else { |
|
870 @@ -6125,41 +6577,261 @@ |
|
871 assert(Output.isNothing() && "Invalid output."); |
|
872 } |
|
873 |
|
874 + const char* Values = "values-Xa.o"; |
|
875 + const char* Xpg = "values-xpg4.o"; |
|
876 + |
|
877 + Arg *STDArg = Args.getLastArg(options::OPT_std_EQ); |
|
878 + if (STDArg) { |
|
879 + if (STDArg->getOption().matches(options::OPT_std_EQ)) { |
|
880 + std::string Lang = STDArg->getValue(); |
|
881 + if ((Lang == "c99") || (Lang == "c11") || |
|
882 + (Lang == "c++11") || (Lang == "c++14")) { |
|
883 + Values = "values-Xc.o"; |
|
884 + Xpg = "values-xpg6.o"; |
|
885 + } |
|
886 + } |
|
887 + } |
|
888 + |
|
889 + const char *gldm = 0; |
|
890 + if (Linker == "/usr/gnu/bin/ld.bfd" || Linker == "/usr/gnu/bin/ld.gold" || |
|
891 + Linker == "/usr/gnu/bin/ld" || Linker == "/usr/bin/gld") { |
|
892 + switch (Arch) { |
|
893 + case llvm::Triple::x86: |
|
894 + if (m32) |
|
895 + gldm = "-m elf_i386"; |
|
896 + else |
|
897 + gldm = "-m elf_x86_64"; |
|
898 + break; |
|
899 + case llvm::Triple::x86_64: |
|
900 + if (m32) |
|
901 + gldm = "-m elf_i386"; |
|
902 + else |
|
903 + gldm = "-m elf_x86_64"; |
|
904 + break; |
|
905 + case llvm::Triple::sparc: |
|
906 + if (m32) |
|
907 + gldm = "-m elf32_sparc"; |
|
908 + else |
|
909 + gldm = "-m elf64_sparc"; |
|
910 + break; |
|
911 + case llvm::Triple::sparcv9: |
|
912 + if (m32) |
|
913 + gldm = "-m elf32_sparc"; |
|
914 + else |
|
915 + gldm = "-m elf64_sparc"; |
|
916 + break; |
|
917 + default: |
|
918 + break; |
|
919 + } |
|
920 + |
|
921 + if (gldm) |
|
922 + CmdArgs.push_back(Args.MakeArgString(StringRef(gldm))); |
|
923 + |
|
924 + if (Linker == "/usr/gnu/bin/ld.gold") { |
|
925 + if (Args.hasArg(options::OPT_O)) |
|
926 + Args.AddAllArgs(CmdArgs, options::OPT_O); |
|
927 + } |
|
928 + } |
|
929 + |
|
930 + if (Args.hasArg(options::OPT_v)) |
|
931 + CmdArgs.push_back(Args.MakeArgString(StringRef("-V"))); |
|
932 + |
|
933 + CmdArgs.push_back(Args.MakeArgString(StringRef("-Qy"))); |
|
934 + if (Linker == "/usr/bin/ld") { |
|
935 + CmdArgs.push_back(Args.MakeArgString(StringRef("-Y"))); |
|
936 + CmdArgs.push_back(Args.MakeArgString(StringRef("P," + YPPath))); |
|
937 + } else { |
|
938 + CmdArgs.push_back(Args.MakeArgString(StringRef("-Y"))); |
|
939 + CmdArgs.push_back(Args.MakeArgString(StringRef(YPPath))); |
|
940 + } |
|
941 + |
|
942 + CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath)); |
|
943 + |
|
944 + std::string P = GCCLibPath; |
|
945 + P += "../../.."; |
|
946 + CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + P)); |
|
947 + |
|
948 + std::string crt1o; |
|
949 + |
|
950 if (!Args.hasArg(options::OPT_nostdlib) && |
|
951 !Args.hasArg(options::OPT_nostartfiles)) { |
|
952 if (!Args.hasArg(options::OPT_shared)) { |
|
953 - CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o")); |
|
954 + switch (Arch) { |
|
955 + case llvm::Triple::sparc: |
|
956 + case llvm::Triple::sparcv9: |
|
957 + crt1o = GCCLibPath; |
|
958 + break; |
|
959 + case llvm::Triple::x86: |
|
960 + case llvm::Triple::x86_64: |
|
961 + crt1o = LibPath; |
|
962 + break; |
|
963 + default: |
|
964 + D.Diag(diag::err_target_unsupported_arch) << T.getArchName() |
|
965 + << T.getTriple(); |
|
966 + break; |
|
967 + } |
|
968 + |
|
969 + crt1o += "/crt1.o"; |
|
970 + |
|
971 + CmdArgs.push_back(Args.MakeArgString(crt1o.c_str())); |
|
972 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o")); |
|
973 - CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o")); |
|
974 + CmdArgs.push_back(Args.MakeArgString(LibPath + Values)); |
|
975 + CmdArgs.push_back(Args.MakeArgString(LibPath + Xpg)); |
|
976 + CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + GCCLibPath)); |
|
977 + CmdArgs.push_back(Args.MakeArgString("-L" + P)); |
|
978 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o")); |
|
979 } else { |
|
980 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o")); |
|
981 - CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o")); |
|
982 + CmdArgs.push_back(Args.MakeArgString(LibPath + Values)); |
|
983 + CmdArgs.push_back(Args.MakeArgString(LibPath + Xpg)); |
|
984 + CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + GCCLibPath)); |
|
985 + CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + P)); |
|
986 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o")); |
|
987 } |
|
988 - if (getToolChain().getDriver().CCCIsCXX()) |
|
989 - CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o")); |
|
990 + } else if (Args.hasArg(options::OPT_nostdlib) && |
|
991 + !Args.hasArg(options::OPT_nostartfiles)) { |
|
992 + if (Args.hasArg(options::OPT_shared)) { |
|
993 + CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o")); |
|
994 + CmdArgs.push_back(Args.MakeArgString(LibPath + Values)); |
|
995 + CmdArgs.push_back(Args.MakeArgString(LibPath + Xpg)); |
|
996 + CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + GCCLibPath)); |
|
997 + CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + P)); |
|
998 + CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o")); |
|
999 + } else { |
|
1000 + CmdArgs.push_back(Args.MakeArgString(crt1o.c_str())); |
|
1001 + CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o")); |
|
1002 + CmdArgs.push_back(Args.MakeArgString(LibPath + Values)); |
|
1003 + CmdArgs.push_back(Args.MakeArgString(LibPath + Xpg)); |
|
1004 + CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + GCCLibPath)); |
|
1005 + CmdArgs.push_back(Args.MakeArgString("-L" + P)); |
|
1006 } |
|
1007 + } else if (!Args.hasArg(options::OPT_nostdlib) && |
|
1008 + Args.hasArg(options::OPT_nostartfiles)) { |
|
1009 + if (Args.hasArg(options::OPT_shared)) { |
|
1010 + CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o")); |
|
1011 + } |
|
1012 + } |
|
1013 |
|
1014 - CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath)); |
|
1015 + // Itanium C++ ABI. |
|
1016 + std::string CXAFinalize; |
|
1017 + bool HasSystemCXAFinalize = false; |
|
1018 |
|
1019 + if (!Args.hasArg(options::OPT_shared)) { |
|
1020 + if (PIEArg) { |
|
1021 + if (PIEArg->getOption().matches(options::OPT_fPIE) || |
|
1022 + PIEArg->getOption().matches(options::OPT_fpie)) { |
|
1023 + CXAFinalize = ClangLibPath + "cxa_finalize_pic.o"; |
|
1024 + } |
|
1025 + } else { |
|
1026 + CXAFinalize = ClangLibPath + "cxa_finalize.o"; |
|
1027 + } |
|
1028 + |
|
1029 + HasSystemCXAFinalize = llvm::sys::fs::exists(CXAFinalize.c_str()); |
|
1030 + |
|
1031 + if (D.CCCIsCXX() && HasSystemCXAFinalize) |
|
1032 + CmdArgs.push_back(Args.MakeArgString(CXAFinalize.c_str())); |
|
1033 + } |
|
1034 + |
|
1035 + CmdArgs.push_back(Args.MakeArgString(StringRef("-L" + GCCLibPath))); |
|
1036 + CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath)); |
|
1037 + CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + ShortLibPath)); |
|
1038 + |
|
1039 Args.AddAllArgs(CmdArgs, options::OPT_L); |
|
1040 + const ToolChain::path_list Paths = TC.getFilePaths(); |
|
1041 + for (ToolChain::path_list::const_iterator B = Paths.begin(), E = Paths.end(); |
|
1042 + B != E; ++B) { |
|
1043 + CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *B)); |
|
1044 + |
|
1045 + // Itanium C++ ABI. |
|
1046 + if (!Args.hasArg(options::OPT_shared)) { |
|
1047 + if (D.CCCIsCXX() && !HasSystemCXAFinalize) { |
|
1048 + if (PIEArg) { |
|
1049 + if (PIEArg->getOption().matches(options::OPT_fPIE) || |
|
1050 + PIEArg->getOption().matches(options::OPT_fpie)) { |
|
1051 + CXAFinalize = *B + "/cxa_finalize_pic.o"; |
|
1052 + } |
|
1053 + } else { |
|
1054 + CXAFinalize = *B + "/cxa_finalize.o"; |
|
1055 + } |
|
1056 + |
|
1057 + if (llvm::sys::fs::exists(CXAFinalize.c_str())) |
|
1058 + CmdArgs.push_back(Args.MakeArgString(CXAFinalize.c_str())); |
|
1059 + } |
|
1060 + } |
|
1061 + } |
|
1062 + |
|
1063 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); |
|
1064 Args.AddAllArgs(CmdArgs, options::OPT_e); |
|
1065 + Args.AddAllArgs(CmdArgs, options::OPT_s); |
|
1066 + Args.AddAllArgs(CmdArgs, options::OPT_t); |
|
1067 Args.AddAllArgs(CmdArgs, options::OPT_r); |
|
1068 |
|
1069 - AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); |
|
1070 + std::vector<std::string> zoptions = Args.getAllArgValues(options::OPT_z); |
|
1071 + std::string zoption; |
|
1072 |
|
1073 + for (std::vector<std::string>::const_iterator B = zoptions.begin(), |
|
1074 + E = zoptions.end(); B != E; ++B) { |
|
1075 + zoption = "-z"; |
|
1076 + zoption += *B; |
|
1077 + CmdArgs.push_back(Args.MakeArgString(StringRef(zoption))); |
|
1078 + } |
|
1079 + |
|
1080 + if (!Args.hasArg(options::OPT_mimpure_text) && |
|
1081 + !Args.hasArg(options::OPT_fpie) && |
|
1082 + !Args.hasArg(options::OPT_fPIE)) |
|
1083 + CmdArgs.push_back(Args.MakeArgString(StringRef("-ztext"))); |
|
1084 + |
|
1085 + // Itanium C++ ABI. |
|
1086 + if (D.CCCIsCXX()) { |
|
1087 + if (!Args.hasArg(options::OPT_shared)) { |
|
1088 + const char* zfiniarray = "-zfiniarray=__cxa_finalize"; |
|
1089 + CmdArgs.push_back(Args.MakeArgString(zfiniarray)); |
|
1090 + } |
|
1091 + } |
|
1092 + |
|
1093 + if (Linker == "/usr/gnu/bin/ld.gold" || Linker == "/usr/gnu/bin/ld" || |
|
1094 + Linker == "/usr/gnu/bin/ld.bfd") { |
|
1095 + CmdArgs.push_back("-plugin"); |
|
1096 + std::string Plugin = D.Dir + "/../lib/LLVMgold.so"; |
|
1097 + CmdArgs.push_back(Args.MakeArgString(Plugin)); |
|
1098 + } else { |
|
1099 + CmdArgs.push_back(moption); |
|
1100 + } |
|
1101 + |
|
1102 + if (Arg *A = Args.getLastArg(options::OPT_rpath)) { |
|
1103 + StringRef V = A->getValue(); |
|
1104 + if (Linker == "/usr/gnu/bin/ld.gold" || Linker == "/usr/gnu/bin/ld" || |
|
1105 + Linker == "/usr/gnu/bin/ld.bfd") { |
|
1106 + CmdArgs.push_back(Args.MakeArgString("-rpath")); |
|
1107 + CmdArgs.push_back(Args.MakeArgString(V)); |
|
1108 + } else { |
|
1109 + CmdArgs.push_back(Args.MakeArgString("-R")); |
|
1110 + CmdArgs.push_back(Args.MakeArgString(V)); |
|
1111 + } |
|
1112 + } |
|
1113 + |
|
1114 + AddLinkerInputs(TC, Inputs, Args, CmdArgs); |
|
1115 + AddLibgcc(D, CmdArgs, Args, Linker.str()); |
|
1116 + |
|
1117 if (!Args.hasArg(options::OPT_nostdlib) && |
|
1118 !Args.hasArg(options::OPT_nodefaultlibs)) { |
|
1119 - if (getToolChain().getDriver().CCCIsCXX()) |
|
1120 - getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); |
|
1121 - CmdArgs.push_back("-lgcc_s"); |
|
1122 - if (!Args.hasArg(options::OPT_shared)) { |
|
1123 - CmdArgs.push_back("-lgcc"); |
|
1124 + if (D.CCCIsCXX()) |
|
1125 + TC.AddCXXStdlibLibArgs(Args, CmdArgs); |
|
1126 + |
|
1127 CmdArgs.push_back("-lc"); |
|
1128 CmdArgs.push_back("-lm"); |
|
1129 + CmdArgs.push_back("-lgcc_s"); |
|
1130 + |
|
1131 + if (Args.hasArg(options::OPT_static)) { |
|
1132 + CmdArgs.push_back("-lgcc"); |
|
1133 + CmdArgs.push_back("-lgcc_eh"); |
|
1134 } |
|
1135 + } else if (Args.hasArg(options::OPT_nostdlib) && |
|
1136 + (!Args.hasArg(options::OPT_nodefaultlibs))) { |
|
1137 + CmdArgs.push_back("-lgcc_s"); |
|
1138 + |
|
1139 + if (Args.hasArg(options::OPT_static)) |
|
1140 + CmdArgs.push_back("-lgcc_eh"); |
|
1141 } |
|
1142 |
|
1143 if (!Args.hasArg(options::OPT_nostdlib) && |
|
1144 @@ -6166,15 +6838,17 @@ |
|
1145 !Args.hasArg(options::OPT_nostartfiles)) { |
|
1146 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o")); |
|
1147 } |
|
1148 + |
|
1149 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o")); |
|
1150 |
|
1151 - addProfileRT(getToolChain(), Args, CmdArgs); |
|
1152 + addProfileRT(TC, Args, CmdArgs); |
|
1153 |
|
1154 - const char *Exec = |
|
1155 - Args.MakeArgString(getToolChain().GetLinkerPath()); |
|
1156 - C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); |
|
1157 + C.addCommand(llvm::make_unique<Command>(JA, *this, |
|
1158 + Args.MakeArgString(Linker), |
|
1159 + CmdArgs)); |
|
1160 } |
|
1161 |
|
1162 + |
|
1163 void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, |
|
1164 const InputInfo &Output, |
|
1165 const InputInfoList &Inputs, |
|
1166 @@ -7280,6 +7954,40 @@ |
|
1167 if (isAndroid && !StaticLibgcc) |
|
1168 CmdArgs.push_back("-ldl"); |
|
1169 } |
|
1170 + |
|
1171 +static void AddLibgcc(const Driver &D, ArgStringList &CmdArgs, |
|
1172 + const ArgList &Args, const std::string& Exec) { |
|
1173 + bool StaticLibgcc = Args.hasArg(options::OPT_static) || |
|
1174 + Args.hasArg(options::OPT_static_libgcc); |
|
1175 + if (!D.CCCIsCXX()) |
|
1176 + CmdArgs.push_back("-lgcc"); |
|
1177 + |
|
1178 + if (StaticLibgcc) { |
|
1179 + if (D.CCCIsCXX()) |
|
1180 + CmdArgs.push_back("-lgcc"); |
|
1181 + } else { |
|
1182 + if ((!D.CCCIsCXX()) && ((Exec == "/usr/bin/gld") || |
|
1183 + (Exec == "/usr/gnu/bin/ld") || |
|
1184 + (Exec == "/usr/gnu/bin/ld.bfd") || |
|
1185 + (Exec == "/usr/gnu/bin/ld.gold"))) |
|
1186 + CmdArgs.push_back("--as-needed"); |
|
1187 + |
|
1188 + CmdArgs.push_back("-lgcc_s"); |
|
1189 + if ((!D.CCCIsCXX()) && ((Exec == "/usr/bin/gld") || |
|
1190 + (Exec == "/usr/gnu/bin/ld") || |
|
1191 + (Exec == "/usr/gnu/bin/ld.bfd") || |
|
1192 + (Exec == "/usr/gnu/bin/ld.gold"))) |
|
1193 + CmdArgs.push_back("--no-as-needed"); |
|
1194 + } |
|
1195 + |
|
1196 + if (StaticLibgcc) |
|
1197 + CmdArgs.push_back("-lgcc_eh"); |
|
1198 + else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX()) |
|
1199 + CmdArgs.push_back("-lgcc"); |
|
1200 + |
|
1201 + if (!StaticLibgcc) |
|
1202 + CmdArgs.push_back("-ldl"); |
|
1203 +} |
|
1204 |
|
1205 static std::string getLinuxDynamicLinker(const ArgList &Args, |
|
1206 const toolchains::Linux &ToolChain) { |
|
1207 --- tools/clang/lib/Driver/ToolChains.h 2015-08-29 19:24:32.064113013 -0700 |
|
1208 +++ tools/clang/lib/Driver/ToolChains.h 2015-08-30 12:42:03.657485673 -0700 |
|
1209 @@ -508,16 +508,106 @@ |
|
1210 llvm::opt::ArgStringList &CC1Args) const override; |
|
1211 }; |
|
1212 |
|
1213 -class LLVM_LIBRARY_VISIBILITY Solaris : public Generic_GCC { |
|
1214 +class LLVM_LIBRARY_VISIBILITY Solaris : public Generic_ELF { |
|
1215 public: |
|
1216 Solaris(const Driver &D, const llvm::Triple &Triple, |
|
1217 const llvm::opt::ArgList &Args); |
|
1218 |
|
1219 - bool IsIntegratedAssemblerDefault() const override { return true; } |
|
1220 + bool IsIntegratedAssemblerDefault() const override { return !UseGnuAs; } |
|
1221 + |
|
1222 + std::string computeSysRoot() const; |
|
1223 + |
|
1224 + bool addLibStdCXXIncludePaths(Twine Base, Twine Suffix, |
|
1225 + StringRef GCCTriple, |
|
1226 + StringRef GCCMultiarchTriple, |
|
1227 + StringRef TargetMultiarchTriple, |
|
1228 + Twine IncludeSuffix, |
|
1229 + const llvm::opt::ArgList &DriverArgs, |
|
1230 + llvm::opt::ArgStringList &CC1Args) const; |
|
1231 + |
|
1232 + void addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir, |
|
1233 + const llvm::opt::ArgList &DriverArgs, |
|
1234 + llvm::opt::ArgStringList &CC1Args) const; |
|
1235 + |
|
1236 + void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, |
|
1237 + llvm::opt::ArgStringList &CC1Args) const override; |
|
1238 + |
|
1239 + void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, |
|
1240 + llvm::opt::ArgStringList &CC1Args) const override; |
|
1241 + |
|
1242 + void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, |
|
1243 + llvm::opt::ArgStringList &CC1Args) const override; |
|
1244 + |
|
1245 + void findGCCMajorMinor() const; |
|
1246 + void findGCCMajorMinorMicro(const llvm::Triple &Triple) const; |
|
1247 + void findGCCIncludeDirs(const llvm::Triple &Triple, |
|
1248 + const llvm::opt::ArgList &Args) const; |
|
1249 + void findGCCInternalLibDir(const llvm::Triple &Triple, |
|
1250 + const llvm::opt::ArgList &Args) const; |
|
1251 + void findSpecifiedGCCToolchain(const char *StartingPath, |
|
1252 + const llvm::Triple &Triple, |
|
1253 + const llvm::opt::ArgList &Args) const; |
|
1254 + |
|
1255 + StringRef getAssembler() const { return Assembler.c_str(); } |
|
1256 + StringRef getLinker() const { return Linker.c_str(); } |
|
1257 + StringRef getGCCInstallDir() const { return GCCInstallDir.c_str(); } |
|
1258 + StringRef getGCCMajorMinor() const { return GCCMajorMinor.c_str(); } |
|
1259 + StringRef getMArch() const { return march.c_str(); } |
|
1260 + StringRef getMTune() const { return mtune.c_str(); } |
|
1261 + StringRef getMCpu() const { return mcpu.c_str(); } |
|
1262 + StringRef getGCCInternalLibDir() const { return GCCInternalLibDir; } |
|
1263 + |
|
1264 + StringRef getGCCInternalMultiLibDir() const { |
|
1265 + return GCCInternalMultiLibDir; |
|
1266 + } |
|
1267 + |
|
1268 + StringRef getGCCMajorMinorMicro() const { |
|
1269 + return GCCMajorMinorMicro.c_str(); |
|
1270 + } |
|
1271 + |
|
1272 + const std::vector<std::string> &getGCCIncludeDirs() const { |
|
1273 + return GCCIncludeDirs; |
|
1274 + } |
|
1275 + |
|
1276 + const std::vector<std::string> &getExtraOpts() const { |
|
1277 + return ExtraOpts; |
|
1278 + } |
|
1279 + |
|
1280 + bool isValid() const { return IsValid; } |
|
1281 + |
|
1282 + void print(raw_ostream &OS) const; |
|
1283 + |
|
1284 protected: |
|
1285 Tool *buildAssembler() const override; |
|
1286 Tool *buildLinker() const override; |
|
1287 + void validate(); |
|
1288 + |
|
1289 +private: |
|
1290 + bool UseGnuAs; |
|
1291 + bool UseGnuLd; |
|
1292 + bool UseGoldLd; |
|
1293 + bool UseSunLd; |
|
1294 + mutable bool UseMediatedGCCToolChainPath; |
|
1295 + mutable bool UseSpecifiedGCCToolChainPath; |
|
1296 + bool IsValid; |
|
1297 + |
|
1298 +protected: |
|
1299 + mutable std::string GCCInstallDir; |
|
1300 + mutable std::string GCCMajorMinor; |
|
1301 + mutable std::string GCCMajorMinorMicro; |
|
1302 + mutable std::string GCCInternalLibDir; |
|
1303 + mutable std::string GCCInternalMultiLibDir; |
|
1304 + mutable std::vector<std::string> GCCIncludeDirs; |
|
1305 + |
|
1306 + mutable std::string Assembler; |
|
1307 + mutable std::string Linker; |
|
1308 + mutable std::string mtune; |
|
1309 + mutable std::string march; |
|
1310 + mutable std::string mcpu; |
|
1311 |
|
1312 + mutable std::vector<std::string> ExtraOpts; |
|
1313 + static const char *MediatedGCCToolChainPath; |
|
1314 + static const bool SupportsClangLibCPlusPlus; |
|
1315 }; |
|
1316 |
|
1317 |
|
1318 --- tools/clang/lib/Driver/ToolChains.cpp 2015-04-27 01:13:25.000000000 -0700 |
|
1319 +++ tools/clang/lib/Driver/ToolChains.cpp 2015-08-30 13:11:52.217344511 -0700 |
|
1320 @@ -28,8 +28,10 @@ |
|
1321 #include "llvm/Support/FileSystem.h" |
|
1322 #include "llvm/Support/MemoryBuffer.h" |
|
1323 #include "llvm/Support/Path.h" |
|
1324 +#include "llvm/Support/Host.h" |
|
1325 #include "llvm/Support/Program.h" |
|
1326 #include "llvm/Support/raw_ostream.h" |
|
1327 + |
|
1328 #include <cstdlib> // ::getenv |
|
1329 #include <system_error> |
|
1330 |
|
1331 @@ -38,6 +40,19 @@ |
|
1332 using namespace clang; |
|
1333 using namespace llvm::opt; |
|
1334 |
|
1335 +#if defined(LLVM_ON_UNIX) |
|
1336 +#include <cstring> |
|
1337 +#include <cctype> |
|
1338 +#include <sys/types.h> |
|
1339 +#include <sys/stat.h> |
|
1340 +#include <dirent.h> |
|
1341 +#include <unistd.h> |
|
1342 +#endif |
|
1343 + |
|
1344 +/// \brief Get our best guess at the multiarch triple for a target. |
|
1345 +static std::string getMultiarchTriple(const llvm::Triple &TargetTriple, |
|
1346 + StringRef SysRoot); |
|
1347 + |
|
1348 MachO::MachO(const Driver &D, const llvm::Triple &Triple, |
|
1349 const ArgList &Args) |
|
1350 : ToolChain(D, Triple, Args) { |
|
1351 @@ -1214,6 +1229,11 @@ |
|
1352 // If we have a SysRoot, try that first. |
|
1353 if (!D.SysRoot.empty()) { |
|
1354 Prefixes.push_back(D.SysRoot); |
|
1355 + |
|
1356 + // Add Solaris-specific GCC locations. |
|
1357 + if (TargetTriple.getOS() == llvm::Triple::Solaris) |
|
1358 + Prefixes.push_back("/usr/gcc"); |
|
1359 + |
|
1360 Prefixes.push_back(D.SysRoot + "/usr"); |
|
1361 } |
|
1362 |
|
1363 @@ -1303,20 +1323,24 @@ |
|
1364 static const char *const ARMebHFTriples[] = { "armeb-linux-gnueabihf", |
|
1365 "armebv7hl-redhat-linux-gnueabi" }; |
|
1366 |
|
1367 - static const char *const X86_64LibDirs[] = { "/lib64", "/lib" }; |
|
1368 + static const char *const X86_64LibDirs[] = { "/lib64", "/lib/amd64", |
|
1369 + "/lib/64", "/lib" }; |
|
1370 static const char *const X86_64Triples[] = { |
|
1371 "x86_64-linux-gnu", "x86_64-unknown-linux-gnu", "x86_64-pc-linux-gnu", |
|
1372 "x86_64-redhat-linux6E", "x86_64-redhat-linux", "x86_64-suse-linux", |
|
1373 "x86_64-manbo-linux-gnu", "x86_64-linux-gnu", "x86_64-slackware-linux", |
|
1374 - "x86_64-linux-android", "x86_64-unknown-linux" |
|
1375 + "x86_64-linux-android", "x86_64-unknown-linux", "x86_64-pc-solaris2.11", |
|
1376 + "x86_64-pc-solaris2.12", "x86_64-pc-solaris2.13" |
|
1377 }; |
|
1378 + |
|
1379 static const char *const X32LibDirs[] = { "/libx32" }; |
|
1380 static const char *const X86LibDirs[] = { "/lib32", "/lib" }; |
|
1381 static const char *const X86Triples[] = { |
|
1382 "i686-linux-gnu", "i686-pc-linux-gnu", "i486-linux-gnu", "i386-linux-gnu", |
|
1383 "i386-redhat-linux6E", "i686-redhat-linux", "i586-redhat-linux", |
|
1384 "i386-redhat-linux", "i586-suse-linux", "i486-slackware-linux", |
|
1385 - "i686-montavista-linux", "i686-linux-android", "i586-linux-gnu" |
|
1386 + "i686-montavista-linux", "i686-linux-android", "i586-linux-gnu", |
|
1387 + "i386-pc-solaris2.11", "i386-pc-solaris2.12", "i386-pc-solaris2.13" |
|
1388 }; |
|
1389 |
|
1390 static const char *const MIPSLibDirs[] = { "/lib" }; |
|
1391 @@ -1358,10 +1382,18 @@ |
|
1392 |
|
1393 static const char *const SPARCv8LibDirs[] = { "/lib32", "/lib" }; |
|
1394 static const char *const SPARCv8Triples[] = { "sparc-linux-gnu", |
|
1395 - "sparcv8-linux-gnu" }; |
|
1396 - static const char *const SPARCv9LibDirs[] = { "/lib64", "/lib" }; |
|
1397 + "sparcv8-linux-gnu", |
|
1398 + "sparc-sun-solaris2.11", |
|
1399 + "sparc-sun-solaris2.12", |
|
1400 + "sparc-sun-solaris2.13" }; |
|
1401 + |
|
1402 + static const char *const SPARCv9LibDirs[] = { "/lib64", "/lib/sparcv9", |
|
1403 + "/lib/64", "/lib" }; |
|
1404 static const char *const SPARCv9Triples[] = { "sparc64-linux-gnu", |
|
1405 - "sparcv9-linux-gnu" }; |
|
1406 + "sparcv9-linux-gnu", |
|
1407 + "sparcv9-sun-solaris2.11", |
|
1408 + "sparcv9-sun-solaris2.12", |
|
1409 + "sparcv9-sun-solaris2.13" }; |
|
1410 |
|
1411 static const char *const SystemZLibDirs[] = { "/lib64", "/lib" }; |
|
1412 static const char *const SystemZTriples[] = { |
|
1413 @@ -2649,16 +2681,703 @@ |
|
1414 |
|
1415 /// Solaris - Solaris tool chain which can call as(1) and ld(1) directly. |
|
1416 |
|
1417 +const char *Solaris::MediatedGCCToolChainPath = |
|
1418 +"/path/to/mediated/gcc/toolchain"; |
|
1419 +const bool Solaris::SupportsClangLibCPlusPlus = false; |
|
1420 + |
|
1421 Solaris::Solaris(const Driver &D, const llvm::Triple& Triple, |
|
1422 - const ArgList &Args) |
|
1423 - : Generic_GCC(D, Triple, Args) { |
|
1424 + const llvm::opt::ArgList &Args) |
|
1425 + : Generic_ELF(D, Triple, Args), |
|
1426 + UseGnuAs(true), |
|
1427 + UseGnuLd(false), |
|
1428 + UseGoldLd(false), |
|
1429 + UseSunLd(true), |
|
1430 + UseMediatedGCCToolChainPath(false), |
|
1431 + UseSpecifiedGCCToolChainPath(false), |
|
1432 + IsValid(false), |
|
1433 + GCCInstallDir("/usr/gcc/"), |
|
1434 + GCCMajorMinor(""), |
|
1435 + GCCMajorMinorMicro(""), |
|
1436 + GCCInternalLibDir(""), |
|
1437 + GCCInternalMultiLibDir(""), |
|
1438 + GCCIncludeDirs(), |
|
1439 + Assembler("/usr/gnu/bin/as"), |
|
1440 + Linker("/usr/bin/ld"), |
|
1441 + mtune(""), |
|
1442 + march(""), |
|
1443 + mcpu(""), |
|
1444 + ExtraOpts() { |
|
1445 + if (Arg *A = Args.getLastArg(options::OPT_gcc_toolchain)) { |
|
1446 + GCCInstallDir = A->getValue(); |
|
1447 + if (!llvm::sys::fs::exists(GCCInstallDir)) |
|
1448 + D.Diag(diag::err_drv_no_such_file) << GCCInstallDir; |
|
1449 + else { |
|
1450 + findSpecifiedGCCToolchain(GCCInstallDir.c_str(), Triple, Args); |
|
1451 |
|
1452 - getProgramPaths().push_back(getDriver().getInstalledDir()); |
|
1453 + if (!UseSpecifiedGCCToolChainPath) { |
|
1454 + D.Diag(diag::err_drv_unsupported_rtlib_for_platform) |
|
1455 + << GCCInstallDir << Triple.getTriple(); |
|
1456 + } else { |
|
1457 + findGCCIncludeDirs(Triple, Args); |
|
1458 + findGCCInternalLibDir(Triple, Args); |
|
1459 + } |
|
1460 + } |
|
1461 + } else if (llvm::sys::fs::exists(Solaris::MediatedGCCToolChainPath)) { |
|
1462 + GCCInstallDir = Solaris::MediatedGCCToolChainPath; |
|
1463 + UseMediatedGCCToolChainPath = true; |
|
1464 + } else { |
|
1465 + findGCCMajorMinor(); |
|
1466 + findGCCMajorMinorMicro(Triple); |
|
1467 + findGCCIncludeDirs(Triple, Args); |
|
1468 + findGCCInternalLibDir(Triple, Args); |
|
1469 + } |
|
1470 + |
|
1471 + if (Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ)) { |
|
1472 + Linker = A->getValue(); |
|
1473 + if (Linker == "bfd") |
|
1474 + Linker = "/usr/gnu/bin/ld"; |
|
1475 + else if (Linker == "gold") |
|
1476 + Linker = "/usr/gnu/bin/ld.gold"; |
|
1477 + |
|
1478 + if ((Linker == "/usr/gnu/bin/ld") || (Linker == "/usr/gnu/bin/ld.bfd") || |
|
1479 + (Linker == "/usr/bin/gld") || (Linker == "/usr/bin/gld.bfd")) { |
|
1480 + UseGnuLd = true; |
|
1481 + UseGoldLd = false; |
|
1482 + UseSunLd = false; |
|
1483 + } else if ((Linker == "/usr/gnu/bin/ld.gold") || |
|
1484 + (Linker == "/usr/bin/gld.gold") || |
|
1485 + (Linker == "/usr/bin/ld.gold")) { |
|
1486 + UseGnuLd = false; |
|
1487 + UseSunLd = false; |
|
1488 + UseGoldLd = true; |
|
1489 + } |
|
1490 + } |
|
1491 + |
|
1492 + if (Arg *A = Args.getLastArg(options::OPT_fuse_as_EQ)) { |
|
1493 + Assembler = A->getValue(); |
|
1494 + if (Assembler == "llvm") |
|
1495 + UseGnuAs = false; |
|
1496 + else if ((Assembler == "/usr/gnu/bin/as") || |
|
1497 + (Assembler == "/usr/bin/gas")) |
|
1498 + UseGnuAs = true; |
|
1499 + else if (Assembler == "gas") { |
|
1500 + Assembler = "/usr/gnu/bin/as"; |
|
1501 + UseGnuAs = true; |
|
1502 + } else if ((Assembler == "/usr/bin/as") || (Assembler == "sun") || |
|
1503 + (Assembler == "solaris")) |
|
1504 + D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args); |
|
1505 + } |
|
1506 + |
|
1507 + getProgramPaths().push_back(GCCInstallDir); |
|
1508 if (getDriver().getInstalledDir() != getDriver().Dir) |
|
1509 getProgramPaths().push_back(getDriver().Dir); |
|
1510 |
|
1511 + llvm::Triple::ArchType Arch = Triple.getArch(); |
|
1512 + |
|
1513 + switch (Arch) { |
|
1514 + case llvm::Triple::x86: |
|
1515 + getFilePaths().push_back(getDriver().Dir + "/../lib"); |
|
1516 + getFilePaths().push_back("/usr/lib"); |
|
1517 + march = mtune = "i686"; |
|
1518 + break; |
|
1519 + case llvm::Triple::sparc: |
|
1520 + getFilePaths().push_back(getDriver().Dir + "/../lib"); |
|
1521 + getFilePaths().push_back("/usr/lib"); |
|
1522 + mcpu = "ultrasparc"; |
|
1523 + mtune = "ultrasparc"; |
|
1524 + march = "v8plusa"; |
|
1525 + break; |
|
1526 + case llvm::Triple::x86_64: |
|
1527 + getFilePaths().push_back(getDriver().Dir + "/../lib/amd64"); |
|
1528 + getFilePaths().push_back("/usr/lib/amd64"); |
|
1529 + march = mtune = "opteron"; |
|
1530 + break; |
|
1531 + case llvm::Triple::sparcv9: |
|
1532 + getFilePaths().push_back(getDriver().Dir + "/../lib/sparcv9"); |
|
1533 + getFilePaths().push_back("/usr/lib/sparcv9"); |
|
1534 + mcpu = "ultrasparc"; |
|
1535 + mtune = "ultrasparc"; |
|
1536 + march = "v9a"; |
|
1537 + break; |
|
1538 + default: |
|
1539 getFilePaths().push_back(getDriver().Dir + "/../lib"); |
|
1540 getFilePaths().push_back("/usr/lib"); |
|
1541 + break; |
|
1542 + } |
|
1543 + |
|
1544 + validate(); |
|
1545 + |
|
1546 + if (Args.hasArg(options::OPT_v)) |
|
1547 + this->print(llvm::errs()); |
|
1548 +} |
|
1549 + |
|
1550 +std::string Solaris::computeSysRoot() const { |
|
1551 + if (!getDriver().SysRoot.empty()) |
|
1552 + return getDriver().SysRoot; |
|
1553 + |
|
1554 + return std::string("/"); |
|
1555 +} |
|
1556 + |
|
1557 +bool Solaris::addLibStdCXXIncludePaths(Twine Base, Twine Suffix, |
|
1558 + StringRef GCCTriple, |
|
1559 + StringRef GCCMultiarchTriple, |
|
1560 + StringRef TargetMultiarchTriple, |
|
1561 + Twine IncludeSuffix, |
|
1562 + const llvm::opt::ArgList &DriverArgs, |
|
1563 + llvm::opt::ArgStringList &CC1Args) const { |
|
1564 + if (!llvm::sys::fs::exists(Base + Suffix)) |
|
1565 + return false; |
|
1566 + |
|
1567 + addSystemInclude(DriverArgs, CC1Args, Base); |
|
1568 + addSystemInclude(DriverArgs, CC1Args, Base + Suffix); |
|
1569 + |
|
1570 + if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) || |
|
1571 + llvm::sys::fs::exists(Base + Suffix + "/" + GCCTriple + IncludeSuffix)) { |
|
1572 + addSystemInclude(DriverArgs, |
|
1573 + CC1Args, Base + Suffix + "/" + GCCTriple + IncludeSuffix); |
|
1574 + } else { |
|
1575 + addSystemInclude(DriverArgs, CC1Args, |
|
1576 + Base + "/" + GCCMultiarchTriple + Suffix + IncludeSuffix); |
|
1577 + addSystemInclude(DriverArgs, CC1Args, |
|
1578 + Base + "/" + TargetMultiarchTriple + Suffix); |
|
1579 + } |
|
1580 + |
|
1581 + addSystemInclude(DriverArgs, CC1Args, Base + "/backward"); |
|
1582 + addSystemInclude(DriverArgs, CC1Args, Base + Suffix + "/backward"); |
|
1583 + return true; |
|
1584 +} |
|
1585 + |
|
1586 +void Solaris::AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, |
|
1587 + llvm::opt::ArgStringList &CC1Args) const { |
|
1588 + if (DriverArgs.hasArg(options::OPT_nostdlibinc) || |
|
1589 + DriverArgs.hasArg(options::OPT_nostdincxx)) |
|
1590 + return; |
|
1591 + |
|
1592 + const Driver &D = getDriver(); |
|
1593 + |
|
1594 + // Check for Clang libc++ |
|
1595 + if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) { |
|
1596 + if (!Solaris::SupportsClangLibCPlusPlus) { |
|
1597 + D.Diag(diag::err_drv_invalid_stdlib_name) << "libc++"; |
|
1598 + return; |
|
1599 + } |
|
1600 + |
|
1601 + StringRef IncludePath = "/usr/include/libc++/v1"; |
|
1602 + if (!llvm::sys::fs::exists(IncludePath)) { |
|
1603 + D.Diag(diag::err_drv_no_such_file) << IncludePath; |
|
1604 + return; |
|
1605 + } |
|
1606 + |
|
1607 + addSystemInclude(DriverArgs, CC1Args, IncludePath); |
|
1608 + return; |
|
1609 + } |
|
1610 + |
|
1611 + for (std::vector<std::string>::const_iterator B = |
|
1612 + getGCCIncludeDirs().begin(), E = getGCCIncludeDirs().end(); |
|
1613 + B != E; ++B) { |
|
1614 + llvm::Twine IncludePath((*B)); |
|
1615 + addSystemInclude(DriverArgs, CC1Args, IncludePath); |
|
1616 + } |
|
1617 +} |
|
1618 + |
|
1619 +void Solaris::AddClangSystemIncludeArgs(const ArgList &DriverArgs, |
|
1620 + ArgStringList &CC1Args) const { |
|
1621 + const Driver &D = getDriver(); |
|
1622 + |
|
1623 + if (DriverArgs.hasArg(options::OPT_nostdinc)) |
|
1624 + return; |
|
1625 + |
|
1626 + std::string SysRoot = computeSysRoot(); |
|
1627 + |
|
1628 + if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) { |
|
1629 + SmallString<PATH_MAX> P(D.ResourceDir); |
|
1630 + llvm::sys::path::append(P, "/include"); |
|
1631 + addSystemInclude(DriverArgs, CC1Args, P.str()); |
|
1632 + } |
|
1633 + |
|
1634 + if (DriverArgs.hasArg(options::OPT_nostdlibinc)) |
|
1635 + return; |
|
1636 + |
|
1637 + StringRef CIncludeDirs(C_INCLUDE_DIRS); |
|
1638 + if (CIncludeDirs != "") { |
|
1639 + SmallVector<StringRef, 5> dirs; |
|
1640 + CIncludeDirs.split(dirs, ":"); |
|
1641 + for (SmallVectorImpl<StringRef>::iterator I = dirs.begin(), E = dirs.end(); |
|
1642 + I != E; ++I) { |
|
1643 + StringRef Prefix = |
|
1644 + llvm::sys::path::is_absolute(*I) ? StringRef(SysRoot) : ""; |
|
1645 + addExternCSystemInclude(DriverArgs, CC1Args, Prefix + *I); |
|
1646 + } |
|
1647 + } |
|
1648 + |
|
1649 + addExternCSystemInclude(DriverArgs, CC1Args, "/usr/include"); |
|
1650 +} |
|
1651 + |
|
1652 +void Solaris::addClangTargetOptions(const ArgList &DriverArgs, |
|
1653 + ArgStringList &CC1Args) const { |
|
1654 + const llvm::Triple& TT = getTriple(); |
|
1655 + llvm::Triple::ArchType Arch = TT.getArch(); |
|
1656 + |
|
1657 + if (Arg *A = DriverArgs.getLastArg(options::OPT_mtune_EQ)) { |
|
1658 + StringRef V = A->getValue(); |
|
1659 + if (!V.empty()) |
|
1660 + mtune = V.str(); |
|
1661 + |
|
1662 + // FIXME: Impplement SPARC target features. |
|
1663 + CC1Args.push_back(DriverArgs.MakeArgString("-target-feature")); |
|
1664 + if (Arch == llvm::Triple::sparc || Arch == llvm::Triple::sparcv9) { |
|
1665 + std::string S = "mtune="; |
|
1666 + S += mtune; |
|
1667 + CC1Args.push_back(DriverArgs.MakeArgString(S.c_str())); |
|
1668 + } else { |
|
1669 + CC1Args.push_back(DriverArgs.MakeArgString(mtune.c_str())); |
|
1670 + } |
|
1671 + } |
|
1672 + |
|
1673 + if (Arg *A = DriverArgs.getLastArg(options::OPT_march_EQ)) { |
|
1674 + StringRef V = A->getValue(); |
|
1675 + if (!V.empty()) |
|
1676 + march = V.str(); |
|
1677 + |
|
1678 + CC1Args.push_back(DriverArgs.MakeArgString("-target-feature")); |
|
1679 + |
|
1680 + if ((Arch == llvm::Triple::sparc) || (Arch == llvm::Triple::sparcv9)) { |
|
1681 + std::string S = "march="; |
|
1682 + S += mtune; |
|
1683 + CC1Args.push_back(DriverArgs.MakeArgString(S.c_str())); |
|
1684 + } else { |
|
1685 + CC1Args.push_back(DriverArgs.MakeArgString(march.c_str())); |
|
1686 + } |
|
1687 + } |
|
1688 + |
|
1689 + if (Arch == llvm::Triple::sparc || Arch == llvm::Triple::sparcv9) { |
|
1690 + if (Arg *A = DriverArgs.getLastArg(options::OPT_mcpu_EQ)) { |
|
1691 + StringRef V = A->getValue(); |
|
1692 + if (!V.empty()) |
|
1693 + mcpu = V.str(); |
|
1694 + else |
|
1695 + mcpu = "ultrasparc"; |
|
1696 + } |
|
1697 + |
|
1698 + CC1Args.push_back(DriverArgs.MakeArgString("-target-feature")); |
|
1699 + std::string S = "mcpu="; |
|
1700 + S += mcpu; |
|
1701 + CC1Args.push_back(DriverArgs.MakeArgString(S.c_str())); |
|
1702 + |
|
1703 + if (Arg *A = DriverArgs.getLastArg(options::OPT_mvis)) { |
|
1704 + CC1Args.push_back(DriverArgs.MakeArgString("-target-feature")); |
|
1705 + CC1Args.push_back(DriverArgs.MakeArgString("vis")); |
|
1706 + } else if (Arg *A = DriverArgs.getLastArg(options::OPT_mvis2)) { |
|
1707 + CC1Args.push_back(DriverArgs.MakeArgString("-target-feature")); |
|
1708 + CC1Args.push_back(DriverArgs.MakeArgString("vis2")); |
|
1709 + } else if (Arg *A = DriverArgs.getLastArg(options::OPT_mvis3)) { |
|
1710 + CC1Args.push_back(DriverArgs.MakeArgString("-target-feature")); |
|
1711 + CC1Args.push_back(DriverArgs.MakeArgString("vis3")); |
|
1712 + } |
|
1713 + } |
|
1714 +} |
|
1715 + |
|
1716 +void Solaris::findGCCMajorMinor() const { |
|
1717 + // FIXME: Add 5.2 after testing the ABI. |
|
1718 + static const char* const GCCMM[] = { "4.8", "4.9" }; |
|
1719 + |
|
1720 + const char* P; |
|
1721 + std::string Path; |
|
1722 + |
|
1723 + if (UseMediatedGCCToolChainPath) { |
|
1724 + // FIXME: IMPLEMENT. |
|
1725 + // Needs spec. |
|
1726 + } |
|
1727 + |
|
1728 + Path.reserve(std::string::size_type(PATH_MAX)); |
|
1729 + |
|
1730 + for (int I = (llvm::array_lengthof(GCCMM) - 1); I >= 0; --I) { |
|
1731 + if ((P = GCCMM[I]) != NULL) { |
|
1732 + Path = GCCInstallDir; |
|
1733 + Path.append(P); |
|
1734 + Path.append("/"); |
|
1735 + |
|
1736 + if (llvm::sys::fs::exists(Path.c_str())) { |
|
1737 + GCCMajorMinor = P; |
|
1738 + break; |
|
1739 + } |
|
1740 + } |
|
1741 + } |
|
1742 +} |
|
1743 + |
|
1744 +void Solaris::findGCCMajorMinorMicro(const llvm::Triple& T) const { |
|
1745 + // FIXME: Add 5.2.0 after testing the ABI. |
|
1746 + static const char* const GCCMMM[] = { "4.8.2", "4.8.5", "4.9.3" }; |
|
1747 + |
|
1748 + const char* P; |
|
1749 + std::string Path; |
|
1750 + std::string TripleString = llvm::sys::getDefaultTargetTriple(); |
|
1751 + llvm::Triple::ArchType Arch = T.getArch(); |
|
1752 + |
|
1753 + if (UseMediatedGCCToolChainPath) { |
|
1754 + // FIXME: IMPLEMENT. |
|
1755 + // Needs spec. |
|
1756 + } |
|
1757 + |
|
1758 + Path.reserve(std::string::size_type(PATH_MAX)); |
|
1759 + |
|
1760 + for (int I = (llvm::array_lengthof(GCCMMM) - 1); I >= 0; --I) { |
|
1761 + if ((P = GCCMMM[I]) != NULL) { |
|
1762 + if ((P[0] == GCCMajorMinor[0]) && (P[2] == GCCMajorMinor[2])) { |
|
1763 + Path = GCCInstallDir; |
|
1764 + Path.append("/"); |
|
1765 + Path.append(GCCMajorMinor); |
|
1766 + Path.append("/lib/gcc/"); |
|
1767 + Path.append(TripleString); |
|
1768 + Path.append("/"); |
|
1769 + Path.append(P); |
|
1770 + |
|
1771 + if (llvm::sys::fs::exists(Path.c_str())) { |
|
1772 + std::string Test; |
|
1773 + // Check if this is a real GCC installation and not just |
|
1774 + // an empty directory tree |
|
1775 + switch (Arch) { |
|
1776 + case llvm::Triple::x86: |
|
1777 + case llvm::Triple::sparc: |
|
1778 + Test = Path + "/crtbegin.o"; |
|
1779 + break; |
|
1780 + case llvm::Triple::x86_64: |
|
1781 + Test = Path + "/amd64/crtbegin.o"; |
|
1782 + break; |
|
1783 + case llvm::Triple::sparcv9: |
|
1784 + Test = Path + "/sparcv9/crtbegin.o"; |
|
1785 + break; |
|
1786 + default: |
|
1787 + break; |
|
1788 + } |
|
1789 + |
|
1790 + if (llvm::sys::fs::exists(Test.c_str())) { |
|
1791 + GCCMajorMinorMicro = P; |
|
1792 + break; |
|
1793 + } |
|
1794 + } |
|
1795 + } |
|
1796 + } |
|
1797 + } |
|
1798 +} |
|
1799 + |
|
1800 +void Solaris::findSpecifiedGCCToolchain(const char *StartingPath, |
|
1801 + const llvm::Triple &Triple, |
|
1802 + const llvm::opt::ArgList &Args) const { |
|
1803 + DIR *TopLD = 0; |
|
1804 + DIR *LibLD = 0; |
|
1805 + DIR *GccLD = 0; |
|
1806 + DIR *TripleLD = 0; |
|
1807 + struct dirent *TopDE = 0; |
|
1808 + struct dirent *LibDE = 0; |
|
1809 + struct dirent *GccDE = 0; |
|
1810 + struct dirent *TripleDE = 0; |
|
1811 + std::string LibDir; |
|
1812 + std::string GccDir; |
|
1813 + std::string TripleDir; |
|
1814 + std::string TripleVersionDir; |
|
1815 + const char *DName; |
|
1816 + |
|
1817 + assert(StartingPath && "Invalid GCC Toolchain starting search path!"); |
|
1818 + |
|
1819 + GCCMajorMinor = ""; |
|
1820 + GCCMajorMinorMicro = ""; |
|
1821 + UseSpecifiedGCCToolChainPath = false; |
|
1822 + |
|
1823 + LibDir.reserve(std::string::size_type(PATH_MAX)); |
|
1824 + GccDir.reserve(std::string::size_type(PATH_MAX)); |
|
1825 + TripleDir.reserve(std::string::size_type(PATH_MAX)); |
|
1826 + TripleVersionDir.reserve(std::string::size_type(PATH_MAX)); |
|
1827 + |
|
1828 + if (llvm::sys::fs::exists(StartingPath) && |
|
1829 + llvm::sys::fs::is_directory(StartingPath)) { |
|
1830 + TopLD = opendir(StartingPath); |
|
1831 + assert(TopLD && "Cannot obtain a valid toplevel DIR handle!"); |
|
1832 + |
|
1833 + while ((TopDE = readdir(TopLD)) != NULL) { |
|
1834 + if (TopDE->d_name[0] == '.') |
|
1835 + continue; |
|
1836 + |
|
1837 + DName = reinterpret_cast<const char*>(&TopDE->d_name[0]); |
|
1838 + if (std::strcmp(DName, "lib") == 0) { |
|
1839 + LibDir = StartingPath; |
|
1840 + LibDir.append("/"); |
|
1841 + LibDir.append(DName); |
|
1842 + |
|
1843 + if (!llvm::sys::fs::is_directory(LibDir.c_str())) |
|
1844 + continue; |
|
1845 + |
|
1846 + LibLD = opendir(LibDir.c_str()); |
|
1847 + assert(LibLD && "Could not obtain a valid lib DIR handle!"); |
|
1848 + |
|
1849 + while ((LibDE = readdir(LibLD)) != NULL) { |
|
1850 + if (LibDE->d_name[0] == '.') |
|
1851 + continue; |
|
1852 + |
|
1853 + DName = reinterpret_cast<const char*>(&LibDE->d_name[0]); |
|
1854 + if (std::strcmp(DName, "gcc") == 0) { |
|
1855 + GccDir = LibDir; |
|
1856 + GccDir.append("/"); |
|
1857 + GccDir.append(DName); |
|
1858 + |
|
1859 + if (!llvm::sys::fs::is_directory(GccDir.c_str())) |
|
1860 + continue; |
|
1861 + |
|
1862 + GccLD = opendir(GccDir.c_str()); |
|
1863 + assert(GccLD && "Could not obtain a valid gcc DIR handle!"); |
|
1864 + |
|
1865 + while ((GccDE = readdir(GccLD)) != NULL) { |
|
1866 + if (GccDE->d_name[0] == '.') |
|
1867 + continue; |
|
1868 + |
|
1869 + DName = reinterpret_cast<const char*>(&GccDE->d_name[0]); |
|
1870 + TripleDir = GccDir; |
|
1871 + TripleDir.append("/"); |
|
1872 + TripleDir.append(DName); |
|
1873 + |
|
1874 + if (!llvm::sys::fs::is_directory(TripleDir.c_str())) |
|
1875 + continue; |
|
1876 + |
|
1877 + if ((std::strncmp(DName, "sparc", 5) == 0) || |
|
1878 + (std::strncmp(DName, "i386", 4) == 0) || |
|
1879 + (std::strncmp(DName, "sparcv9", 7) == 0) || |
|
1880 + (std::strncmp(DName, "x86_64", 6) == 0)) { |
|
1881 + TripleLD = opendir(TripleDir.c_str()); |
|
1882 + assert(TripleLD && |
|
1883 + "Could not obtain a valid Triple DIR handle!"); |
|
1884 + |
|
1885 + while ((TripleDE = readdir(TripleLD)) != NULL) { |
|
1886 + if (TripleDE->d_name[0] == '.') |
|
1887 + continue; |
|
1888 + |
|
1889 + DName = reinterpret_cast<const char*>(&TripleDE->d_name[0]); |
|
1890 + TripleVersionDir = TripleDir; |
|
1891 + TripleVersionDir.append("/"); |
|
1892 + TripleVersionDir.append(DName); |
|
1893 + |
|
1894 + if (!llvm::sys::fs::is_directory(TripleVersionDir.c_str())) |
|
1895 + continue; |
|
1896 + |
|
1897 + if ((std::isdigit(DName[0])) && (DName[1] == '.') && |
|
1898 + (std::isdigit(DName[2])) && (DName[3] == '.') && |
|
1899 + (std::isdigit(DName[4])) && (DName[5] == '\0')) { |
|
1900 + GCCMajorMinorMicro = DName; |
|
1901 + GCCMajorMinor = GCCMajorMinorMicro.substr(0, 3); |
|
1902 + UseSpecifiedGCCToolChainPath = true; |
|
1903 + goto done; |
|
1904 + } |
|
1905 + } |
|
1906 + } |
|
1907 + } |
|
1908 + } |
|
1909 + } |
|
1910 + } |
|
1911 + } |
|
1912 + } |
|
1913 + |
|
1914 +done: |
|
1915 + if (TripleLD) { |
|
1916 + rewinddir(TripleLD); |
|
1917 + closedir(TripleLD); |
|
1918 + } |
|
1919 + |
|
1920 + if (GccLD) { |
|
1921 + rewinddir(GccLD); |
|
1922 + closedir(GccLD); |
|
1923 + } |
|
1924 + |
|
1925 + if (LibLD) { |
|
1926 + rewinddir(LibLD); |
|
1927 + closedir(LibLD); |
|
1928 + } |
|
1929 + |
|
1930 + if (TopLD) { |
|
1931 + rewinddir(TopLD); |
|
1932 + closedir(TopLD); |
|
1933 + } |
|
1934 +} |
|
1935 + |
|
1936 + |
|
1937 + |
|
1938 +void Solaris::findGCCIncludeDirs(const llvm::Triple &Triple, |
|
1939 + const llvm::opt::ArgList &Args) const { |
|
1940 + std::string GCCInstallPath; |
|
1941 + if (UseSpecifiedGCCToolChainPath) |
|
1942 + GCCInstallPath = GCCInstallDir; |
|
1943 + else if (UseMediatedGCCToolChainPath) |
|
1944 + GCCInstallPath = Solaris::MediatedGCCToolChainPath; |
|
1945 + else |
|
1946 + GCCInstallPath = GCCInstallDir + GCCMajorMinor; |
|
1947 + |
|
1948 + std::string GCCIncludeDir = |
|
1949 + GCCInstallPath + "/include/c++/" + GCCMajorMinorMicro; |
|
1950 + GCCIncludeDirs.push_back(GCCIncludeDir); |
|
1951 + |
|
1952 + llvm::Triple::ArchType Arch = Triple.getArch(); |
|
1953 + GCCIncludeDir += "/"; |
|
1954 + |
|
1955 + switch (Arch) { |
|
1956 + case llvm::Triple::x86: |
|
1957 + GCCIncludeDir += Triple.getTriple(); |
|
1958 + if (Arg *A = Args.getLastArg(options::OPT_m64)) |
|
1959 + GCCIncludeDir += "/amd64"; |
|
1960 + break; |
|
1961 + case llvm::Triple::sparc: |
|
1962 + GCCIncludeDir += Triple.getTriple(); |
|
1963 + if (Arg *A = Args.getLastArg(options::OPT_m64)) |
|
1964 + GCCIncludeDir += "/sparcv9"; |
|
1965 + break; |
|
1966 + case llvm::Triple::x86_64: |
|
1967 + GCCIncludeDir += "i386-pc-"; |
|
1968 + GCCIncludeDir += Triple.getOSName(); |
|
1969 + if (Arg *A = Args.getLastArg(options::OPT_m64)) |
|
1970 + GCCIncludeDir += "/amd64"; |
|
1971 + break; |
|
1972 + case llvm::Triple::sparcv9: |
|
1973 + GCCIncludeDir += "sparc-sun-"; |
|
1974 + GCCIncludeDir += Triple.getOSName(); |
|
1975 + if (Arg *A = Args.getLastArg(options::OPT_m64)) |
|
1976 + GCCIncludeDir += "/sparcv9"; |
|
1977 + break; |
|
1978 + default: |
|
1979 + getDriver().Diag(diag::err_target_unsupported_arch) |
|
1980 + << Triple.getArchName() << Triple.getTriple(); |
|
1981 + break; |
|
1982 + } |
|
1983 + |
|
1984 + GCCIncludeDirs.push_back(GCCIncludeDir); |
|
1985 + |
|
1986 + GCCIncludeDir = GCCInstallPath + "/include/c++/" + |
|
1987 + GCCMajorMinorMicro + "/backward"; |
|
1988 + |
|
1989 + GCCIncludeDirs.push_back(GCCIncludeDir); |
|
1990 +} |
|
1991 + |
|
1992 +void Solaris::findGCCInternalLibDir(const llvm::Triple &Triple, |
|
1993 + const llvm::opt::ArgList &Args) const { |
|
1994 + std::string GCCInstallPath; |
|
1995 + if (UseSpecifiedGCCToolChainPath) |
|
1996 + GCCInstallPath = GCCInstallDir; |
|
1997 + else if (UseMediatedGCCToolChainPath) |
|
1998 + GCCInstallPath = Solaris::MediatedGCCToolChainPath; |
|
1999 + else |
|
2000 + GCCInstallPath = GCCInstallDir + GCCMajorMinor; |
|
2001 + |
|
2002 + GCCInternalLibDir = GCCInstallPath + "/lib/gcc/"; |
|
2003 + |
|
2004 + llvm::Triple::ArchType Arch = Triple.getArch(); |
|
2005 + |
|
2006 + switch (Arch) { |
|
2007 + case llvm::Triple::x86: |
|
2008 + GCCInternalLibDir += Triple.getTriple(); |
|
2009 + GCCInternalLibDir += "/"; |
|
2010 + GCCInternalLibDir += GCCMajorMinorMicro; |
|
2011 + if (Arg *A = Args.getLastArg(options::OPT_m64)) { |
|
2012 + GCCInternalMultiLibDir = GCCInternalLibDir; |
|
2013 + GCCInternalLibDir += "/amd64"; |
|
2014 + } else if (Arg *A = Args.getLastArg(options::OPT_m32)) { |
|
2015 + GCCInternalMultiLibDir = GCCInternalLibDir; |
|
2016 + GCCInternalMultiLibDir += "/amd64"; |
|
2017 + } else { |
|
2018 + GCCInternalMultiLibDir = GCCInternalLibDir; |
|
2019 + GCCInternalMultiLibDir += "/amd64"; |
|
2020 + } |
|
2021 + |
|
2022 + break; |
|
2023 + case llvm::Triple::sparc: |
|
2024 + GCCInternalLibDir += Triple.getTriple(); |
|
2025 + GCCInternalLibDir += "/"; |
|
2026 + GCCInternalLibDir += GCCMajorMinorMicro; |
|
2027 + if (Arg *A = Args.getLastArg(options::OPT_m64)) { |
|
2028 + GCCInternalMultiLibDir = GCCInternalLibDir; |
|
2029 + GCCInternalLibDir += "/sparcv9"; |
|
2030 + } else if (Arg *A = Args.getLastArg(options::OPT_m32)) { |
|
2031 + GCCInternalMultiLibDir = GCCInternalLibDir; |
|
2032 + GCCInternalMultiLibDir += "/sparcv9"; |
|
2033 + } else { |
|
2034 + GCCInternalMultiLibDir = GCCInternalLibDir; |
|
2035 + GCCInternalMultiLibDir += "/sparcv9"; |
|
2036 + } |
|
2037 + break; |
|
2038 + case llvm::Triple::x86_64: |
|
2039 + GCCInternalLibDir += "i386-pc-"; |
|
2040 + GCCInternalLibDir += Triple.getOSName(); |
|
2041 + GCCInternalLibDir += "/"; |
|
2042 + GCCInternalLibDir += GCCMajorMinorMicro; |
|
2043 + GCCInternalMultiLibDir = GCCInternalLibDir; |
|
2044 + if (Arg *A = Args.getLastArg(options::OPT_m64)) |
|
2045 + GCCInternalLibDir += "/amd64"; |
|
2046 + else if (Arg *A = Args.getLastArg(options::OPT_m32)) |
|
2047 + GCCInternalMultiLibDir += "/amd64"; |
|
2048 + else |
|
2049 + GCCInternalLibDir += "/amd64"; |
|
2050 + break; |
|
2051 + case llvm::Triple::sparcv9: |
|
2052 + GCCInternalLibDir += "sparc-sun-"; |
|
2053 + GCCInternalLibDir += Triple.getOSName(); |
|
2054 + GCCInternalLibDir += "/"; |
|
2055 + GCCInternalLibDir += GCCMajorMinorMicro; |
|
2056 + GCCInternalMultiLibDir = GCCInternalLibDir; |
|
2057 + if (Arg *A = Args.getLastArg(options::OPT_m64)) |
|
2058 + GCCInternalLibDir += "/sparcv9"; |
|
2059 + else if (Arg *A = Args.getLastArg(options::OPT_m32)) |
|
2060 + GCCInternalMultiLibDir += "/sparcv9"; |
|
2061 + else |
|
2062 + GCCInternalLibDir += "/sparcv9"; |
|
2063 + break; |
|
2064 + default: |
|
2065 + getDriver().Diag(diag::err_target_unsupported_arch) |
|
2066 + << Triple.getArchName() << Triple.getTriple(); |
|
2067 + break; |
|
2068 + } |
|
2069 +} |
|
2070 + |
|
2071 +void Solaris::print(raw_ostream &OS) const { |
|
2072 + OS << "UseGnuAs: " << (UseGnuAs ? "true" : "false") << "\n"; |
|
2073 + OS << "UseGnuLd: " << (UseGnuLd ? "true" : "false") << "\n"; |
|
2074 + OS << "UseGoldLd: " << (UseGoldLd ? "true" : "false") << "\n"; |
|
2075 + OS << "UseSunLd: " << (UseSunLd ? "true" : "false") << "\n"; |
|
2076 + OS << "UseMediatedGCCToolChainPath: " |
|
2077 + << (UseMediatedGCCToolChainPath ? "true" : "false") << "\n"; |
|
2078 + OS << "UseSpecifiedGCCToolChainPath: " |
|
2079 + << (UseSpecifiedGCCToolChainPath ? "true" : "false") << "\n"; |
|
2080 + OS << "GCCInstallDir: " << GCCInstallDir.c_str() << "\n"; |
|
2081 + OS << "GCCMajorMinor: " << GCCMajorMinor.c_str() << "\n"; |
|
2082 + OS << "GCCMajorMinorMicro: " << GCCMajorMinorMicro.c_str() << "\n"; |
|
2083 + OS << "GCCInternalLibDir: " << GCCInternalLibDir.c_str() << "\n"; |
|
2084 + OS << "GCCInternalMultiLibDir: " << GCCInternalMultiLibDir.c_str() << "\n"; |
|
2085 + OS << "MediatedGCCToolChainPath: " << MediatedGCCToolChainPath << "\n"; |
|
2086 + OS << "GCCIncludeDirs: "; |
|
2087 + |
|
2088 + if (GCCIncludeDirs.size()) { |
|
2089 + std::string IncludePath; |
|
2090 + for (std::vector<std::string>::const_iterator B = GCCIncludeDirs.begin(), |
|
2091 + E = GCCIncludeDirs.end(); B != E; ++B) { |
|
2092 + IncludePath = "-I"; |
|
2093 + IncludePath += (*B); |
|
2094 + OS << IncludePath.c_str() << " "; |
|
2095 + } |
|
2096 + |
|
2097 + OS << "\n"; |
|
2098 + } |
|
2099 + |
|
2100 + OS << "Assembler: " << Assembler.c_str() << "\n"; |
|
2101 + OS << "Linker: " << Linker.c_str() << "\n"; |
|
2102 + OS << "mtune: " << mtune.c_str() << "\n"; |
|
2103 + OS << "march: " << march.c_str() << "\n"; |
|
2104 + OS << "mcpu: " << mcpu.c_str() << "\n"; |
|
2105 + |
|
2106 + if (ExtraOpts.size()) { |
|
2107 + OS << "ExtraOpts: "; |
|
2108 + for (std::vector<std::string>::const_iterator B = ExtraOpts.begin(), |
|
2109 + E = ExtraOpts.end(); B != E; ++B) { |
|
2110 + OS << (*B).c_str() << " "; |
|
2111 + } |
|
2112 + |
|
2113 + OS << "\n"; |
|
2114 + } |
|
2115 + |
|
2116 + OS << "Valid: " << (IsValid ? "true" : "false") << "\n"; |
|
2117 } |
|
2118 |
|
2119 Tool *Solaris::buildAssembler() const { |
|
2120 @@ -2669,6 +3388,21 @@ |
|
2121 return new tools::solaris::Link(*this); |
|
2122 } |
|
2123 |
|
2124 +void Solaris::validate() { |
|
2125 + IsValid = llvm::sys::fs::exists(GCCInstallDir.c_str()); |
|
2126 + if (!IsValid) return; |
|
2127 + IsValid = llvm::sys::fs::exists(GCCInternalLibDir.c_str()); |
|
2128 + if (!IsValid) return; |
|
2129 + IsValid = llvm::sys::fs::exists(GCCInternalMultiLibDir.c_str()); |
|
2130 + if (!IsValid) return; |
|
2131 + |
|
2132 + for (std::vector<std::string>::const_iterator B = GCCIncludeDirs.begin(), |
|
2133 + E = GCCIncludeDirs.end(); B != E; ++B) { |
|
2134 + IsValid = llvm::sys::fs::exists((*B).c_str()); |
|
2135 + if (!IsValid) return; |
|
2136 + } |
|
2137 +} |
|
2138 + |
|
2139 /// Distribution (very bare-bones at the moment). |
|
2140 |
|
2141 enum Distro { |
|
2142 @@ -2696,6 +3430,27 @@ |
|
2143 UbuntuRaring, |
|
2144 UbuntuSaucy, |
|
2145 UbuntuTrusty, |
|
2146 + Solaris_11, |
|
2147 + Solaris_11_1, |
|
2148 + Solaris_11_2, |
|
2149 + Solaris_11_3, |
|
2150 + Solaris_11_4, |
|
2151 + Solaris_11_5, |
|
2152 + Solaris_11_6, |
|
2153 + Solaris_11_7, |
|
2154 + Solaris_11_8, |
|
2155 + Solaris_11_9, |
|
2156 + Solaris_12, |
|
2157 + Solaris_12_1, |
|
2158 + Solaris_12_2, |
|
2159 + Solaris_12_3, |
|
2160 + Solaris_12_4, |
|
2161 + Solaris_12_5, |
|
2162 + Solaris_12_6, |
|
2163 + Solaris_12_7, |
|
2164 + Solaris_12_8, |
|
2165 + Solaris_12_9, |
|
2166 + Solaris_13, |
|
2167 UnknownDistro |
|
2168 }; |
|
2169 |
|
2170 @@ -2715,6 +3470,10 @@ |
|
2171 return Distro >= UbuntuHardy && Distro <= UbuntuTrusty; |
|
2172 } |
|
2173 |
|
2174 +static bool IsSolaris(enum Distro Distro) { |
|
2175 + return Distro >= Solaris_11 && Distro <= Solaris_13; |
|
2176 +} |
|
2177 + |
|
2178 static Distro DetectDistro(llvm::Triple::ArchType Arch) { |
|
2179 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File = |
|
2180 llvm::MemoryBuffer::getFile("/etc/lsb-release"); |
|
2181 @@ -2774,6 +3533,59 @@ |
|
2182 return UnknownDistro; |
|
2183 } |
|
2184 |
|
2185 + File = llvm::MemoryBuffer::getFile("/etc/release"); |
|
2186 + if (File) { |
|
2187 + StringRef Data = File.get()->getBuffer(); |
|
2188 + SmallVector<StringRef, 8> Lines; |
|
2189 + Data.split(Lines, "\n"); |
|
2190 + for (unsigned I = 0, S = Lines.size(); I != S; ++I) { |
|
2191 + if (Lines[I].find("Oracle Solaris") != std::string::npos) { |
|
2192 + if (Lines[I].find("Solaris 11.0") != std::string::npos) |
|
2193 + return Solaris_11; |
|
2194 + else if (Lines[I].find("Solaris 11.1") != std::string::npos) |
|
2195 + return Solaris_11_1; |
|
2196 + else if (Lines[I].find("Solaris 11.2") != std::string::npos) |
|
2197 + return Solaris_11_2; |
|
2198 + else if (Lines[I].find("Solaris 11.3") != std::string::npos) |
|
2199 + return Solaris_11_3; |
|
2200 + else if (Lines[I].find("Solaris 11.4") != std::string::npos) |
|
2201 + return Solaris_11_4; |
|
2202 + else if (Lines[I].find("Solaris 11.5") != std::string::npos) |
|
2203 + return Solaris_11_5; |
|
2204 + else if (Lines[I].find("Solaris 11.6") != std::string::npos) |
|
2205 + return Solaris_11_6; |
|
2206 + else if (Lines[I].find("Solaris 11.7") != std::string::npos) |
|
2207 + return Solaris_11_7; |
|
2208 + else if (Lines[I].find("Solaris 11.8") != std::string::npos) |
|
2209 + return Solaris_11_8; |
|
2210 + else if (Lines[I].find("Solaris 11.9") != std::string::npos) |
|
2211 + return Solaris_11_9; |
|
2212 + else if (Lines[I].find("Solaris 12.0") != std::string::npos) |
|
2213 + return Solaris_12; |
|
2214 + else if (Lines[I].find("Solaris 12.1") != std::string::npos) |
|
2215 + return Solaris_12_1; |
|
2216 + else if (Lines[I].find("Solaris 12.2") != std::string::npos) |
|
2217 + return Solaris_12_2; |
|
2218 + else if (Lines[I].find("Solaris 12.3") != std::string::npos) |
|
2219 + return Solaris_12_3; |
|
2220 + else if (Lines[I].find("Solaris 12.4") != std::string::npos) |
|
2221 + return Solaris_12_4; |
|
2222 + else if (Lines[I].find("Solaris 12.5") != std::string::npos) |
|
2223 + return Solaris_12_5; |
|
2224 + else if (Lines[I].find("Solaris 12.6") != std::string::npos) |
|
2225 + return Solaris_12_6; |
|
2226 + else if (Lines[I].find("Solaris 12.7") != std::string::npos) |
|
2227 + return Solaris_12_7; |
|
2228 + else if (Lines[I].find("Solaris 12.8") != std::string::npos) |
|
2229 + return Solaris_12_8; |
|
2230 + else if (Lines[I].find("Solaris 12.9") != std::string::npos) |
|
2231 + return Solaris_12_9; |
|
2232 + } |
|
2233 + } |
|
2234 + |
|
2235 + return UnknownDistro; |
|
2236 + } |
|
2237 + |
|
2238 if (llvm::sys::fs::exists("/etc/SuSE-release")) |
|
2239 return OpenSUSE; |
|
2240 |
|
2241 --- tools/llvm-shlib/Makefile Sat Jul 18 11:44:45 2015 |
|
2242 +++ tools/llvm-shlib/Makefile Thu Aug 20 23:40:28 2015 |
|
2243 @@ -74,6 +74,7 @@ |
|
2244 LLVMLibsOptions := -Wl,-z -Wl,rescan -Wl,-z -Wl,allextract $(LLVMLibsOptions) |
|
2245 LLVMLibsOptions += -Wl,-h -Wl,lib$(LIBRARYNAME)$(SHLIBEXT) |
|
2246 LLVMLibsOptions += -Wl,-z -Wl,defaultextract -Wl,-z -Wl,defs |
|
2247 + LLVMLibsOptions += -lkstat |
|
2248 endif |
|
2249 |
|
2250 ifeq ($(HOST_OS), $(filter $(HOST_OS), Cygwin MingW)) |
|
2251 --- tools/clang/lib/Basic/Targets.cpp 2015-08-26 11:44:48.659904739 -0700 |
|
2252 +++ tools/clang/lib/Basic/Targets.cpp 2015-08-26 11:47:36.318310023 -0700 |
|
2253 @@ -530,28 +530,60 @@ |
|
2254 template<typename Target> |
|
2255 class SolarisTargetInfo : public OSTargetInfo<Target> { |
|
2256 protected: |
|
2257 - void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, |
|
2258 + virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, |
|
2259 MacroBuilder &Builder) const override { |
|
2260 DefineStd(Builder, "sun", Opts); |
|
2261 DefineStd(Builder, "unix", Opts); |
|
2262 Builder.defineMacro("__ELF__"); |
|
2263 Builder.defineMacro("__svr4__"); |
|
2264 Builder.defineMacro("__SVR4"); |
|
2265 - // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and |
|
2266 - // newer, but to 500 for everything else. feature_test.h has a check to |
|
2267 - // ensure that you are not using C99 with an old version of X/Open or C89 |
|
2268 - // with a new version. |
|
2269 - if (Opts.C99) |
|
2270 + |
|
2271 + if (Opts.C99 || Opts.CPlusPlus11) { |
|
2272 + if (Opts.C99) { |
|
2273 Builder.defineMacro("_XOPEN_SOURCE", "600"); |
|
2274 - else |
|
2275 + Builder.defineMacro("_XPG6", "1"); |
|
2276 + } |
|
2277 + |
|
2278 + Builder.defineMacro("__STDC_VERSION__", "199901L"); |
|
2279 + Builder.defineMacro("_STDC_C99", "1"); |
|
2280 + Builder.defineMacro("__C99FEATURES__", "1"); |
|
2281 + } |
|
2282 + |
|
2283 + if (Opts.CPlusPlus11) |
|
2284 + Builder.defineMacro("__cplusplus", "201103L"); |
|
2285 + else if (Opts.CPlusPlus14) |
|
2286 + Builder.defineMacro("__cplusplus", "201402L"); |
|
2287 + |
|
2288 + if (Opts.CPlusPlus11) { |
|
2289 + Builder.defineMacro("_STDC_C11", "1"); |
|
2290 + Builder.defineMacro("_STDC_C11_BCI", "1"); |
|
2291 + Builder.defineMacro("__XPG7_THREAD_MODEL__", "1"); |
|
2292 + Builder.defineMacro("_XPG7", "1"); |
|
2293 + Builder.defineMacro("_XOPEN_SOURCE", "700"); |
|
2294 + } else if (Opts.C11 || Opts.CPlusPlus14) { |
|
2295 + Builder.defineMacro("__STDC_VERSION__", "201112L"); |
|
2296 + Builder.defineMacro("_STDC_C11", "1"); |
|
2297 + Builder.defineMacro("_STDC_C11_BCI", "1"); |
|
2298 + Builder.defineMacro("__XPG7_THREAD_MODEL__", "1"); |
|
2299 + Builder.defineMacro("_XPG7", "1"); |
|
2300 + Builder.defineMacro("_XOPEN_SOURCE", "700"); |
|
2301 + } else { |
|
2302 Builder.defineMacro("_XOPEN_SOURCE", "500"); |
|
2303 - if (Opts.CPlusPlus) |
|
2304 - Builder.defineMacro("__C99FEATURES__"); |
|
2305 + Builder.defineMacro("__STDC_VERSION__", "199409L"); |
|
2306 + if (Opts.CPlusPlus && !Opts.CPlusPlus11 && !Opts.CPlusPlus14) |
|
2307 + Builder.defineMacro("__cplusplus", "199711L"); |
|
2308 + } |
|
2309 + |
|
2310 + if ((Triple.getArchName() == "i386") || (Triple.getArchName() == "sparc")) |
|
2311 Builder.defineMacro("_LARGEFILE_SOURCE"); |
|
2312 + else if ((Triple.getArchName() == "x86_64") || |
|
2313 + (Triple.getArchName() == "sparcv9")) |
|
2314 Builder.defineMacro("_LARGEFILE64_SOURCE"); |
|
2315 - Builder.defineMacro("__EXTENSIONS__"); |
|
2316 + |
|
2317 + Builder.defineMacro("__EXTENSIONS__", "1"); |
|
2318 Builder.defineMacro("_REENTRANT"); |
|
2319 } |
|
2320 + |
|
2321 public: |
|
2322 SolarisTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) { |
|
2323 this->UserLabelPrefix = ""; |