Diff 131043

cfe/trunk/lib/Driver/ToolChains/Gnu.h

Show First 20 Lines • Show All 244 Lines • ▼ Show 20 Lines	private:
static void		static void
CollectLibDirsAndTriples(const llvm::Triple &TargetTriple,		CollectLibDirsAndTriples(const llvm::Triple &TargetTriple,
const llvm::Triple &BiarchTriple,		const llvm::Triple &BiarchTriple,
SmallVectorImpl<StringRef> &LibDirs,		SmallVectorImpl<StringRef> &LibDirs,
SmallVectorImpl<StringRef> &TripleAliases,		SmallVectorImpl<StringRef> &TripleAliases,
SmallVectorImpl<StringRef> &BiarchLibDirs,		SmallVectorImpl<StringRef> &BiarchLibDirs,
SmallVectorImpl<StringRef> &BiarchTripleAliases);		SmallVectorImpl<StringRef> &BiarchTripleAliases);

		void AddDefaultGCCPrefixes(const llvm::Triple &TargetTriple,
		SmallVectorImpl<std::string> &Prefixes,
		StringRef SysRoot);

bool ScanGCCForMultilibs(const llvm::Triple &TargetTriple,		bool ScanGCCForMultilibs(const llvm::Triple &TargetTriple,
const llvm::opt::ArgList &Args,		const llvm::opt::ArgList &Args,
StringRef Path,		StringRef Path,
bool NeedsBiarchSuffix = false);		bool NeedsBiarchSuffix = false);

void ScanLibDirForGCCTriple(const llvm::Triple &TargetArch,		void ScanLibDirForGCCTriple(const llvm::Triple &TargetArch,
const llvm::opt::ArgList &Args,		const llvm::opt::ArgList &Args,
const std::string &LibDir,		const std::string &LibDir,
StringRef CandidateTriple,		StringRef CandidateTriple,
bool NeedsBiarchSuffix = false);		bool NeedsBiarchSuffix = false);

void scanLibDirForGCCTripleSolaris(const llvm::Triple &TargetArch,
const llvm::opt::ArgList &Args,
const std::string &LibDir,
StringRef CandidateTriple,
bool NeedsBiarchSuffix = false);

bool ScanGentooGccConfig(const llvm::Triple &TargetTriple,		bool ScanGentooGccConfig(const llvm::Triple &TargetTriple,
const llvm::opt::ArgList &Args,		const llvm::opt::ArgList &Args,
StringRef CandidateTriple,		StringRef CandidateTriple,
bool NeedsBiarchSuffix = false);		bool NeedsBiarchSuffix = false);
};		};

protected:		protected:
GCCInstallationDetector GCCInstallation;		GCCInstallationDetector GCCInstallation;
Show All 24 Lines	protected:
/// @{		/// @{

/// \brief Check whether the target triple's architecture is 64-bits.		/// \brief Check whether the target triple's architecture is 64-bits.
bool isTarget64Bit() const { return getTriple().isArch64Bit(); }		bool isTarget64Bit() const { return getTriple().isArch64Bit(); }

/// \brief Check whether the target triple's architecture is 32-bits.		/// \brief Check whether the target triple's architecture is 32-bits.
bool isTarget32Bit() const { return getTriple().isArch32Bit(); }		bool isTarget32Bit() const { return getTriple().isArch32Bit(); }

// FIXME: This should be final, but the Solaris tool chain does weird		// FIXME: This should be final, but the CrossWindows toolchain does weird
// things we can't easily represent.		// things that can't be easily generalized.
void AddClangCXXStdlibIncludeArgs(		void AddClangCXXStdlibIncludeArgs(
const llvm::opt::ArgList &DriverArgs,		const llvm::opt::ArgList &DriverArgs,
llvm::opt::ArgStringList &CC1Args) const override;		llvm::opt::ArgStringList &CC1Args) const override;

virtual std::string findLibCxxIncludePath() const;		virtual std::string findLibCxxIncludePath() const;
virtual void		virtual void
addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,		addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
llvm::opt::ArgStringList &CC1Args) const;		llvm::opt::ArgStringList &CC1Args) const;
Show All 33 Lines

cfe/trunk/lib/Driver/ToolChains/Gnu.cpp

Show First 20 Lines • Show All 1,444 Lines • ▼ Show 20 Lines	if (RISCVMultilibs.select(Flags, Result.SelectedMultilib))
Result.Multilibs = RISCVMultilibs;		Result.Multilibs = RISCVMultilibs;
}		}

static bool findBiarchMultilibs(const Driver &D,		static bool findBiarchMultilibs(const Driver &D,
const llvm::Triple &TargetTriple,		const llvm::Triple &TargetTriple,
StringRef Path, const ArgList &Args,		StringRef Path, const ArgList &Args,
bool NeedsBiarchSuffix,		bool NeedsBiarchSuffix,
DetectedMultilibs &Result) {		DetectedMultilibs &Result) {
		Multilib Default;

// Some versions of SUSE and Fedora on ppc64 put 32-bit libs		// Some versions of SUSE and Fedora on ppc64 put 32-bit libs
// in what would normally be GCCInstallPath and put the 64-bit		// in what would normally be GCCInstallPath and put the 64-bit
// libs in a subdirectory named 64. The simple logic we follow is that		// libs in a subdirectory named 64. The simple logic we follow is that
// if there is a subdirectory of the right name with crtbegin.o in it,		// if there is a subdirectory of the right name with crtbegin.o in it,
// we use that. If not, and if not a biarch triple alias, we look for		// we use that. If not, and if not a biarch triple alias, we look for
// crtbegin.o without the subdirectory.		// crtbegin.o without the subdirectory.

Multilib Default;		StringRef Suff64 = "/64";
		// Solaris uses platform-specific suffixes instead of /64.
		if (TargetTriple.getOS() == llvm::Triple::Solaris) {
		switch (TargetTriple.getArch()) {
		case llvm::Triple::x86:
		case llvm::Triple::x86_64:
		Suff64 = "/amd64";
		break;
		case llvm::Triple::sparc:
		case llvm::Triple::sparcv9:
		Suff64 = "/sparcv9";
		break;
		default:
		break;
		}
		}

Multilib Alt64 = Multilib()		Multilib Alt64 = Multilib()
.gccSuffix("/64")		.gccSuffix(Suff64)
.includeSuffix("/64")		.includeSuffix(Suff64)
.flag("-m32")		.flag("-m32")
.flag("+m64")		.flag("+m64")
.flag("-mx32");		.flag("-mx32");
Multilib Alt32 = Multilib()		Multilib Alt32 = Multilib()
.gccSuffix("/32")		.gccSuffix("/32")
.includeSuffix("/32")		.includeSuffix("/32")
.flag("+m32")		.flag("+m32")
.flag("-m64")		.flag("-m64")
▲ Show 20 Lines • Show All 180 Lines • ▼ Show 20 Lines	if (GCCToolchainDir != "") {
if (GCCToolchainDir.back() == '/')		if (GCCToolchainDir.back() == '/')
GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /		GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /

Prefixes.push_back(GCCToolchainDir);		Prefixes.push_back(GCCToolchainDir);
} else {		} else {
// If we have a SysRoot, try that first.		// If we have a SysRoot, try that first.
if (!D.SysRoot.empty()) {		if (!D.SysRoot.empty()) {
Prefixes.push_back(D.SysRoot);		Prefixes.push_back(D.SysRoot);
Prefixes.push_back(D.SysRoot + "/usr");		AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.SysRoot);
}		}

// Then look for gcc installed alongside clang.		// Then look for gcc installed alongside clang.
Prefixes.push_back(D.InstalledDir + "/..");		Prefixes.push_back(D.InstalledDir + "/..");

// Then look for distribution supplied gcc installations.		// Next, look for prefix(es) that correspond to distribution-supplied gcc
		// installations.
if (D.SysRoot.empty()) {		if (D.SysRoot.empty()) {
// Look for RHEL devtoolsets.		// Typically /usr.
Prefixes.push_back("/opt/rh/devtoolset-6/root/usr");		AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.SysRoot);
Prefixes.push_back("/opt/rh/devtoolset-4/root/usr");
Prefixes.push_back("/opt/rh/devtoolset-3/root/usr");
Prefixes.push_back("/opt/rh/devtoolset-2/root/usr");
// And finally in /usr.
Prefixes.push_back("/usr");
}		}
}		}

// Try to respect gcc-config on Gentoo. However, do that only		// Try to respect gcc-config on Gentoo. However, do that only
// if --gcc-toolchain is not provided or equal to the Gentoo install		// if --gcc-toolchain is not provided or equal to the Gentoo install
// in /usr. This avoids accidentally enforcing the system GCC version		// in /usr. This avoids accidentally enforcing the system GCC version
// when using a custom toolchain.		// when using a custom toolchain.
if (GCCToolchainDir == "" \|\| GCCToolchainDir == D.SysRoot + "/usr") {		if (GCCToolchainDir == "" \|\| GCCToolchainDir == D.SysRoot + "/usr") {
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const {		bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const {
if (BiarchSibling.hasValue()) {		if (BiarchSibling.hasValue()) {
M = BiarchSibling.getValue();		M = BiarchSibling.getValue();
return true;		return true;
}		}
return false;		return false;
}		}

		void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes(
		const llvm::Triple &TargetTriple, SmallVectorImpl<std::string> &Prefixes,
		StringRef SysRoot) {
		if (TargetTriple.getOS() == llvm::Triple::Solaris) {
		// Solaris is a special case.
		// The GCC installation is under
		// /usr/gcc/<major>.<minor>/lib/gcc/<triple>/<major>.<minor>.<patch>/
		// so we need to find those /usr/gcc/*/lib/gcc libdirs and go with
		// /usr/gcc/<version> as a prefix.

		std::string PrefixDir = SysRoot.str() + "/usr/gcc";
		std::error_code EC;
		for (vfs::directory_iterator LI = D.getVFS().dir_begin(PrefixDir, EC), LE;
		!EC && LI != LE; LI = LI.increment(EC)) {
		StringRef VersionText = llvm::sys::path::filename(LI->getName());
		GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);

		// Filter out obviously bad entries.
		if (CandidateVersion.Major == -1 \|\| CandidateVersion.isOlderThan(4, 1, 1))
		continue;

		std::string CandidatePrefix = PrefixDir + "/" + VersionText.str();
		std::string CandidateLibPath = CandidatePrefix + "/lib/gcc";
		if (!D.getVFS().exists(CandidateLibPath))
		continue;

		Prefixes.push_back(CandidatePrefix);
		}
		return;
		}

		// Non-Solaris is much simpler - most systems just go with "/usr".
		if (SysRoot.empty()) {
		// Yet, still look for RHEL devtoolsets
		// (should it be done Linux-only??)
		Prefixes.push_back("/opt/rh/devtoolset-6/root/usr");
		Prefixes.push_back("/opt/rh/devtoolset-4/root/usr");
		Prefixes.push_back("/opt/rh/devtoolset-3/root/usr");
		Prefixes.push_back("/opt/rh/devtoolset-2/root/usr");
		Prefixes.push_back("/usr");
		} else {
		Prefixes.push_back(SysRoot.str() + "/usr");
		}
		}

/static/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(		/static/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
const llvm::Triple &TargetTriple, const llvm::Triple &BiarchTriple,		const llvm::Triple &TargetTriple, const llvm::Triple &BiarchTriple,
SmallVectorImpl<StringRef> &LibDirs,		SmallVectorImpl<StringRef> &LibDirs,
SmallVectorImpl<StringRef> &TripleAliases,		SmallVectorImpl<StringRef> &TripleAliases,
SmallVectorImpl<StringRef> &BiarchLibDirs,		SmallVectorImpl<StringRef> &BiarchLibDirs,
SmallVectorImpl<StringRef> &BiarchTripleAliases) {		SmallVectorImpl<StringRef> &BiarchTripleAliases) {
// Declare a bunch of static data sets that we'll select between below. These		// Declare a bunch of static data sets that we'll select between below. These
// are specifically designed to always refer to string literals to avoid any		// are specifically designed to always refer to string literals to avoid any
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines	/static/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
static const char *const SPARCv9Triples[] = {"sparc64-linux-gnu",		static const char *const SPARCv9Triples[] = {"sparc64-linux-gnu",
"sparcv9-linux-gnu"};		"sparcv9-linux-gnu"};

static const char *const SystemZLibDirs[] = {"/lib64", "/lib"};		static const char *const SystemZLibDirs[] = {"/lib64", "/lib"};
static const char *const SystemZTriples[] = {		static const char *const SystemZTriples[] = {
"s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",		"s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",
"s390x-suse-linux", "s390x-redhat-linux"};		"s390x-suse-linux", "s390x-redhat-linux"};

// Solaris.
static const char *const SolarisSPARCLibDirs[] = {"/gcc"};
static const char *const SolarisSPARCTriples[] = {"sparc-sun-solaris2.11",
"i386-pc-solaris2.11"};

using std::begin;		using std::begin;
using std::end;		using std::end;

if (TargetTriple.getOS() == llvm::Triple::Solaris) {		if (TargetTriple.getOS() == llvm::Triple::Solaris) {
LibDirs.append(begin(SolarisSPARCLibDirs), end(SolarisSPARCLibDirs));		static const char *const SolarisLibDirs[] = {"/lib"};
TripleAliases.append(begin(SolarisSPARCTriples), end(SolarisSPARCTriples));		static const char *const SolarisSparcV8Triples[] = {
		"sparc-sun-solaris2.11", "sparc-sun-solaris2.12"};
		static const char *const SolarisSparcV9Triples[] = {
		"sparcv9-sun-solaris2.11", "sparcv9-sun-solaris2.12"};
		static const char *const SolarisX86Triples[] = {"i386-pc-solaris2.11",
		"i386-pc-solaris2.12"};
		static const char *const SolarisX86_64Triples[] = {"x86_64-pc-solaris2.11",
		"x86_64-pc-solaris2.12"};
		LibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
		BiarchLibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
		switch (TargetTriple.getArch()) {
		case llvm::Triple::x86:
		TripleAliases.append(begin(SolarisX86Triples), end(SolarisX86Triples));
		BiarchTripleAliases.append(begin(SolarisX86_64Triples),
		end(SolarisX86_64Triples));
		break;
		case llvm::Triple::x86_64:
		TripleAliases.append(begin(SolarisX86_64Triples),
		end(SolarisX86_64Triples));
		BiarchTripleAliases.append(begin(SolarisX86Triples),
		end(SolarisX86Triples));
		break;
		case llvm::Triple::sparc:
		TripleAliases.append(begin(SolarisSparcV8Triples),
		end(SolarisSparcV8Triples));
		BiarchTripleAliases.append(begin(SolarisSparcV9Triples),
		end(SolarisSparcV9Triples));
		break;
		case llvm::Triple::sparcv9:
		TripleAliases.append(begin(SolarisSparcV9Triples),
		end(SolarisSparcV9Triples));
		BiarchTripleAliases.append(begin(SolarisSparcV8Triples),
		end(SolarisSparcV8Triples));
		break;
		default:
		break;
		}
return;		return;
}		}

switch (TargetTriple.getArch()) {		switch (TargetTriple.getArch()) {
case llvm::Triple::aarch64:		case llvm::Triple::aarch64:
LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));		LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));		TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));		BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
▲ Show 20 Lines • Show All 144 Lines • ▼ Show 20 Lines	/static/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
// match any of our aliases.		// match any of our aliases.
TripleAliases.push_back(TargetTriple.str());		TripleAliases.push_back(TargetTriple.str());

// Also include the multiarch variant if it's different.		// Also include the multiarch variant if it's different.
if (TargetTriple.str() != BiarchTriple.str())		if (TargetTriple.str() != BiarchTriple.str())
BiarchTripleAliases.push_back(BiarchTriple.str());		BiarchTripleAliases.push_back(BiarchTriple.str());
}		}

void Generic_GCC::GCCInstallationDetector::scanLibDirForGCCTripleSolaris(
const llvm::Triple &TargetArch, const llvm::opt::ArgList &Args,
const std::string &LibDir, StringRef CandidateTriple,
bool NeedsBiarchSuffix) {
// Solaris is a special case. The GCC installation is under
// /usr/gcc/<major>.<minor>/lib/gcc/<triple>/<major>.<minor>.<patch>/, so we
// need to iterate twice.
std::error_code EC;
for (vfs::directory_iterator LI = D.getVFS().dir_begin(LibDir, EC), LE;
!EC && LI != LE; LI = LI.increment(EC)) {
StringRef VersionText = llvm::sys::path::filename(LI->getName());
GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);

if (CandidateVersion.Major != -1) // Filter obviously bad entries.
if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
continue; // Saw this path before; no need to look at it again.
if (CandidateVersion.isOlderThan(4, 1, 1))
continue;
if (CandidateVersion <= Version)
continue;

GCCInstallPath =
LibDir + "/" + VersionText.str() + "/lib/gcc/" + CandidateTriple.str();
if (!D.getVFS().exists(GCCInstallPath))
continue;

// If we make it here there has to be at least one GCC version, let's just
// use the latest one.
std::error_code EEC;
for (vfs::directory_iterator
LLI = D.getVFS().dir_begin(GCCInstallPath, EEC),
LLE;
!EEC && LLI != LLE; LLI = LLI.increment(EEC)) {

StringRef SubVersionText = llvm::sys::path::filename(LLI->getName());
GCCVersion CandidateSubVersion = GCCVersion::Parse(SubVersionText);

if (CandidateSubVersion > Version)
Version = CandidateSubVersion;
}

GCCTriple.setTriple(CandidateTriple);

GCCInstallPath += "/" + Version.Text;
GCCParentLibPath = GCCInstallPath + "/../../../../";

IsValid = true;
}
}

bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(		bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(
const llvm::Triple &TargetTriple, const ArgList &Args,		const llvm::Triple &TargetTriple, const ArgList &Args,
StringRef Path, bool NeedsBiarchSuffix) {		StringRef Path, bool NeedsBiarchSuffix) {
llvm::Triple::ArchType TargetArch = TargetTriple.getArch();		llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
DetectedMultilibs Detected;		DetectedMultilibs Detected;

// Android standalone toolchain could have multilibs for ARM and Thumb.		// Android standalone toolchain could have multilibs for ARM and Thumb.
// Debian mips multilibs behave more like the rest of the biarch ones,		// Debian mips multilibs behave more like the rest of the biarch ones,
Show All 17 Lines	bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(

return true;		return true;
}		}

void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(		void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
const llvm::Triple &TargetTriple, const ArgList &Args,		const llvm::Triple &TargetTriple, const ArgList &Args,
const std::string &LibDir, StringRef CandidateTriple,		const std::string &LibDir, StringRef CandidateTriple,
bool NeedsBiarchSuffix) {		bool NeedsBiarchSuffix) {
if (TargetTriple.getOS() == llvm::Triple::Solaris) {
scanLibDirForGCCTripleSolaris(TargetTriple, Args, LibDir, CandidateTriple,
NeedsBiarchSuffix);
return;
}

llvm::Triple::ArchType TargetArch = TargetTriple.getArch();		llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
// Locations relative to the system lib directory where GCC's triple-specific		// Locations relative to the system lib directory where GCC's triple-specific
// directories might reside.		// directories might reside.
struct GCCLibSuffix {		struct GCCLibSuffix {
// Path from system lib directory to GCC triple-specific directory.		// Path from system lib directory to GCC triple-specific directory.
std::string LibSuffix;		std::string LibSuffix;
// Path from GCC triple-specific directory back to system lib directory.		// Path from GCC triple-specific directory back to system lib directory.
// This is one '..' component per component in LibSuffix.		// This is one '..' component per component in LibSuffix.
StringRef ReversePath;		StringRef ReversePath;
// Whether this library suffix is relevant for the triple.		// Whether this library suffix is relevant for the triple.
bool Active;		bool Active;
} Suffixes[] = {		} Suffixes[] = {
// This is the normal place.		// This is the normal place.
{"gcc/" + CandidateTriple.str(), "../..", true},		{"gcc/" + CandidateTriple.str(), "../..", true},

// Debian puts cross-compilers in gcc-cross.		// Debian puts cross-compilers in gcc-cross.
{"gcc-cross/" + CandidateTriple.str(), "../..", true},		{"gcc-cross/" + CandidateTriple.str(), "../..",
		TargetTriple.getOS() != llvm::Triple::Solaris},

// The Freescale PPC SDK has the gcc libraries in		// The Freescale PPC SDK has the gcc libraries in
// <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well. Only do		// <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well. Only do
// this on Freescale triples, though, since some systems put a lot of		// this on Freescale triples, though, since some systems put a lot of
// files in that location, not just GCC installation data.		// files in that location, not just GCC installation data.
{CandidateTriple.str(), "..",		{CandidateTriple.str(), "..",
TargetTriple.getVendor() == llvm::Triple::Freescale},		TargetTriple.getVendor() == llvm::Triple::Freescale},

// Natively multiarch systems sometimes put the GCC triple-specific		// Natively multiarch systems sometimes put the GCC triple-specific
// directory within their multiarch lib directory, resulting in the		// directory within their multiarch lib directory, resulting in the
// triple appearing twice.		// triple appearing twice.
{CandidateTriple.str() + "/gcc/" + CandidateTriple.str(), "../../..", true},		{CandidateTriple.str() + "/gcc/" + CandidateTriple.str(), "../../..",
		TargetTriple.getOS() != llvm::Triple::Solaris},

// Deal with cases (on Ubuntu) where the system architecture could be i386		// Deal with cases (on Ubuntu) where the system architecture could be i386
// but the GCC target architecture could be (say) i686.		// but the GCC target architecture could be (say) i686.
// FIXME: It may be worthwhile to generalize this and look for a second		// FIXME: It may be worthwhile to generalize this and look for a second
// triple.		// triple.
{"i386-linux-gnu/gcc/" + CandidateTriple.str(), "../../..",		{"i386-linux-gnu/gcc/" + CandidateTriple.str(), "../../..",
TargetArch == llvm::Triple::x86}		(TargetArch == llvm::Triple::x86 &&
};		TargetTriple.getOS() != llvm::Triple::Solaris)}};

for (auto &Suffix : Suffixes) {		for (auto &Suffix : Suffixes) {
if (!Suffix.Active)		if (!Suffix.Active)
continue;		continue;

StringRef LibSuffix = Suffix.LibSuffix;		StringRef LibSuffix = Suffix.LibSuffix;
std::error_code EC;		std::error_code EC;
for (vfs::directory_iterator		for (vfs::directory_iterator
▲ Show 20 Lines • Show All 297 Lines • Show Last 20 Lines

cfe/trunk/lib/Driver/ToolChains/Solaris.h

	Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines

	class LLVM_LIBRARY_VISIBILITY Solaris : public Generic_ELF {			class LLVM_LIBRARY_VISIBILITY Solaris : public Generic_ELF {
	public:			public:
	Solaris(const Driver &D, const llvm::Triple &Triple,			Solaris(const Driver &D, const llvm::Triple &Triple,
	const llvm::opt::ArgList &Args);			const llvm::opt::ArgList &Args);

	bool IsIntegratedAssemblerDefault() const override { return true; }			bool IsIntegratedAssemblerDefault() const override { return true; }

	void AddClangCXXStdlibIncludeArgs(			void
	const llvm::opt::ArgList &DriverArgs,			AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
				llvm::opt::ArgStringList &CC1Args) const override;

				void
				addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
	llvm::opt::ArgStringList &CC1Args) const override;			llvm::opt::ArgStringList &CC1Args) const override;

	unsigned GetDefaultDwarfVersion() const override { return 2; }			unsigned GetDefaultDwarfVersion() const override { return 2; }

	protected:			protected:
	Tool *buildAssembler() const override;			Tool *buildAssembler() const override;
	Tool *buildLinker() const override;			Tool *buildLinker() const override;
	};			};

	} // end namespace toolchains			} // end namespace toolchains
	} // end namespace driver			} // end namespace driver
	} // end namespace clang			} // end namespace clang

	#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_SOLARIS_H			#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_SOLARIS_H

cfe/trunk/lib/Driver/ToolChains/Solaris.cpp

Show First 20 Lines • Show All 116 Lines • ▼ Show 20 Lines	void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA,
CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));		CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));

getToolChain().addProfileRTLibs(Args, CmdArgs);		getToolChain().addProfileRTLibs(Args, CmdArgs);

const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());		const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));		C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
}		}

		static StringRef getSolarisLibSuffix(const llvm::Triple &Triple) {
		switch (Triple.getArch()) {
		case llvm::Triple::x86:
		case llvm::Triple::sparc:
		break;
		case llvm::Triple::x86_64:
		return "/amd64";
		case llvm::Triple::sparcv9:
		return "/sparcv9";
		default:
		llvm_unreachable("Unsupported architecture");
		}
		return "";
		}

/// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.		/// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.

Solaris::Solaris(const Driver &D, const llvm::Triple &Triple,		Solaris::Solaris(const Driver &D, const llvm::Triple &Triple,
const ArgList &Args)		const ArgList &Args)
: Generic_ELF(D, Triple, Args) {		: Generic_ELF(D, Triple, Args) {

GCCInstallation.init(Triple, Args);		GCCInstallation.init(Triple, Args);

		StringRef LibSuffix = getSolarisLibSuffix(Triple);
path_list &Paths = getFilePaths();		path_list &Paths = getFilePaths();
if (GCCInstallation.isValid())		if (GCCInstallation.isValid()) {
addPathIfExists(D, GCCInstallation.getInstallPath(), Paths);		// On Solaris gcc uses both an architecture-specific path with triple in it
		// as well as a more generic lib path (+arch suffix).
addPathIfExists(D, getDriver().getInstalledDir(), Paths);		addPathIfExists(D,
if (getDriver().getInstalledDir() != getDriver().Dir)		GCCInstallation.getInstallPath() +
addPathIfExists(D, getDriver().Dir, Paths);		GCCInstallation.getMultilib().gccSuffix(),
		Paths);
addPathIfExists(D, getDriver().SysRoot + getDriver().Dir + "/../lib", Paths);		addPathIfExists(D, GCCInstallation.getParentLibPath() + LibSuffix, Paths);

std::string LibPath = "/usr/lib/";
switch (Triple.getArch()) {
case llvm::Triple::x86:
case llvm::Triple::sparc:
break;
case llvm::Triple::x86_64:
LibPath += "amd64/";
break;
case llvm::Triple::sparcv9:
LibPath += "sparcv9/";
break;
default:
llvm_unreachable("Unsupported architecture");
}		}

addPathIfExists(D, getDriver().SysRoot + LibPath, Paths);		// If we are currently running Clang inside of the requested system root,
		// add its parent library path to those searched.
		if (StringRef(D.Dir).startswith(D.SysRoot))
		addPathIfExists(D, D.Dir + "/../lib", Paths);

		addPathIfExists(D, D.SysRoot + "/usr/lib" + LibSuffix, Paths);
}		}

Tool *Solaris::buildAssembler() const {		Tool *Solaris::buildAssembler() const {
return new tools::solaris::Assembler(*this);		return new tools::solaris::Assembler(*this);
}		}

Tool Solaris::buildLinker() const { return new tools::solaris::Linker(this); }		Tool Solaris::buildLinker() const { return new tools::solaris::Linker(this); }

void Solaris::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,		void Solaris::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
ArgStringList &CC1Args) const {		ArgStringList &CC1Args) const {
if (DriverArgs.hasArg(options::OPT_nostdlibinc) \|\|		const Driver &D = getDriver();
DriverArgs.hasArg(options::OPT_nostdincxx))
		if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc))
		return;

		if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
		addSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/local/include");

		if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
		SmallString<128> P(D.ResourceDir);
		llvm::sys::path::append(P, "include");
		addSystemInclude(DriverArgs, CC1Args, P);
		}

		if (DriverArgs.hasArg(options::OPT_nostdlibinc))
return;		return;

// Include the support directory for things like xlocale and fudged system		// Check for configure-time C include directories.
// headers.		StringRef CIncludeDirs(C_INCLUDE_DIRS);
// FIXME: This is a weird mix of libc++ and libstdc++. We should also be		if (CIncludeDirs != "") {
// checking the value of -stdlib= here and adding the includes for libc++		SmallVector<StringRef, 5> dirs;
// rather than libstdc++ if it's requested.		CIncludeDirs.split(dirs, ":");
addSystemInclude(DriverArgs, CC1Args, "/usr/include/c++/v1/support/solaris");		for (StringRef dir : dirs) {
		StringRef Prefix =
		llvm::sys::path::is_absolute(dir) ? StringRef(D.SysRoot) : "";
		addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir);
		}
		return;
		}

		// Add include directories specific to the selected multilib set and multilib.
if (GCCInstallation.isValid()) {		if (GCCInstallation.isValid()) {
GCCVersion Version = GCCInstallation.getVersion();		const MultilibSet::IncludeDirsFunc &Callback =
addSystemInclude(DriverArgs, CC1Args,		Multilibs.includeDirsCallback();
getDriver().SysRoot + "/usr/gcc/" +		if (Callback) {
Version.MajorStr + "." +		for (const auto &Path : Callback(GCCInstallation.getMultilib()))
Version.MinorStr +		addExternCSystemIncludeIfExists(
"/include/c++/" + Version.Text);		DriverArgs, CC1Args, GCCInstallation.getInstallPath() + Path);
addSystemInclude(DriverArgs, CC1Args,		}
getDriver().SysRoot + "/usr/gcc/" + Version.MajorStr +
"." + Version.MinorStr + "/include/c++/" +
Version.Text + "/" +
GCCInstallation.getTriple().str());
}		}

		addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/include");
		}

		void Solaris::addLibStdCxxIncludePaths(
		const llvm::opt::ArgList &DriverArgs,
		llvm::opt::ArgStringList &CC1Args) const {
		// We need a detected GCC installation on Solaris (similar to Linux)
		// to provide libstdc++'s headers.
		if (!GCCInstallation.isValid())
		return;

		// By default, look for the C++ headers in an include directory adjacent to
		// the lib directory of the GCC installation.
		// On Solaris this usually looks like /usr/gcc/X.Y/include/c++/X.Y.Z
		StringRef LibDir = GCCInstallation.getParentLibPath();
		StringRef TripleStr = GCCInstallation.getTriple().str();
		const Multilib &Multilib = GCCInstallation.getMultilib();
		const GCCVersion &Version = GCCInstallation.getVersion();

		// The primary search for libstdc++ supports multiarch variants.
		addLibStdCXXIncludePaths(LibDir.str() + "/../include", "/c++/" + Version.Text,
		TripleStr,
		/GCCMultiarchTriple/ "",
		/TargetMultiarchTriple/ "",
		Multilib.includeSuffix(), DriverArgs, CC1Args);
}		}

cfe/trunk/lib/Frontend/InitHeaderSearch.cpp

Show First 20 Lines • Show All 249 Lines • ▼ Show 20 Lines	if (CIncludeDirs != "") {
CIncludeDirs.split(dirs, ":");		CIncludeDirs.split(dirs, ":");
for (StringRef dir : dirs)		for (StringRef dir : dirs)
AddPath(dir, ExternCSystem, false);		AddPath(dir, ExternCSystem, false);
return;		return;
}		}

switch (os) {		switch (os) {
case llvm::Triple::Linux:		case llvm::Triple::Linux:
		case llvm::Triple::Solaris:
llvm_unreachable("Include management is handled in the driver.");		llvm_unreachable("Include management is handled in the driver.");

case llvm::Triple::CloudABI: {		case llvm::Triple::CloudABI: {
// <sysroot>/<triple>/include		// <sysroot>/<triple>/include
SmallString<128> P = StringRef(HSOpts.ResourceDir);		SmallString<128> P = StringRef(HSOpts.ResourceDir);
llvm::sys::path::append(P, "../../..", triple.str(), "include");		llvm::sys::path::append(P, "../../..", triple.str(), "include");
AddPath(P, System, false);		AddPath(P, System, false);
break;		break;
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 Lines	case llvm::Triple::aarch64:
"arm64-apple-darwin10", "", "", triple);		"arm64-apple-darwin10", "", "", triple);
break;		break;
}		}
return;		return;
}		}

switch (os) {		switch (os) {
case llvm::Triple::Linux:		case llvm::Triple::Linux:
		case llvm::Triple::Solaris:
llvm_unreachable("Include management is handled in the driver.");		llvm_unreachable("Include management is handled in the driver.");
break;		break;
case llvm::Triple::Win32:		case llvm::Triple::Win32:
switch (triple.getEnvironment()) {		switch (triple.getEnvironment()) {
default: llvm_unreachable("Include management is handled in the driver.");		default: llvm_unreachable("Include management is handled in the driver.");
case llvm::Triple::Cygnus:		case llvm::Triple::Cygnus:
// Cygwin-1.7		// Cygwin-1.7
AddMinGWCPlusPlusIncludePaths("/usr/lib/gcc", "i686-pc-cygwin", "4.7.3");		AddMinGWCPlusPlusIncludePaths("/usr/lib/gcc", "i686-pc-cygwin", "4.7.3");
Show All 31 Lines	void InitHeaderSearch::AddDefaultIncludePaths(const LangOptions &Lang,
// driver which has the information necessary to do target-specific		// driver which has the information necessary to do target-specific
// selections of default include paths. Each target which moves there will be		// selections of default include paths. Each target which moves there will be
// exempted from this logic here until we can delete the entire pile of code.		// exempted from this logic here until we can delete the entire pile of code.
switch (triple.getOS()) {		switch (triple.getOS()) {
default:		default:
break; // Everything else continues to use this routine's logic.		break; // Everything else continues to use this routine's logic.

case llvm::Triple::Linux:		case llvm::Triple::Linux:
		case llvm::Triple::Solaris:
return;		return;

case llvm::Triple::Win32:		case llvm::Triple::Win32:
if (triple.getEnvironment() != llvm::Triple::Cygnus \|\|		if (triple.getEnvironment() != llvm::Triple::Cygnus \|\|
triple.isOSBinFormatMachO())		triple.isOSBinFormatMachO())
return;		return;
break;		break;
}		}
▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

cfe/trunk/test/Driver/Inputs/solaris_sparc_tree/usr/gcc/4.8/include/c++/4.8.2/sparc-sun-solaris2.11/bits/gthr.h