You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
392 lines
15 KiB
392 lines
15 KiB
//===--- Gnu.h - Gnu Tool and ToolChain Implementations ---------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_GNU_H
|
|
#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_GNU_H
|
|
|
|
#include "Cuda.h"
|
|
#include "ROCm.h"
|
|
#include "clang/Driver/Tool.h"
|
|
#include "clang/Driver/ToolChain.h"
|
|
#include <set>
|
|
|
|
namespace clang {
|
|
namespace driver {
|
|
|
|
struct DetectedMultilibs {
|
|
/// The set of multilibs that the detected installation supports.
|
|
MultilibSet Multilibs;
|
|
|
|
/// The primary multilib appropriate for the given flags.
|
|
Multilib SelectedMultilib;
|
|
|
|
/// On Biarch systems, this corresponds to the default multilib when
|
|
/// targeting the non-default multilib. Otherwise, it is empty.
|
|
llvm::Optional<Multilib> BiarchSibling;
|
|
};
|
|
|
|
bool findMIPSMultilibs(const Driver &D, const llvm::Triple &TargetTriple,
|
|
StringRef Path, const llvm::opt::ArgList &Args,
|
|
DetectedMultilibs &Result);
|
|
|
|
namespace tools {
|
|
|
|
/// Directly call GNU Binutils' assembler and linker.
|
|
namespace gnutools {
|
|
class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
|
|
public:
|
|
Assembler(const ToolChain &TC) : Tool("GNU::Assembler", "assembler", TC) {}
|
|
|
|
bool hasIntegratedCPP() const override { return false; }
|
|
|
|
void ConstructJob(Compilation &C, const JobAction &JA,
|
|
const InputInfo &Output, const InputInfoList &Inputs,
|
|
const llvm::opt::ArgList &TCArgs,
|
|
const char *LinkingOutput) const override;
|
|
};
|
|
|
|
class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
|
|
public:
|
|
Linker(const ToolChain &TC) : Tool("GNU::Linker", "linker", TC) {}
|
|
|
|
bool hasIntegratedCPP() const override { return false; }
|
|
bool isLinkJob() const override { return true; }
|
|
|
|
void ConstructJob(Compilation &C, const JobAction &JA,
|
|
const InputInfo &Output, const InputInfoList &Inputs,
|
|
const llvm::opt::ArgList &TCArgs,
|
|
const char *LinkingOutput) const override;
|
|
};
|
|
|
|
class LLVM_LIBRARY_VISIBILITY StaticLibTool : public Tool {
|
|
public:
|
|
StaticLibTool(const ToolChain &TC)
|
|
: Tool("GNU::StaticLibTool", "static-lib-linker", TC) {}
|
|
|
|
bool hasIntegratedCPP() const override { return false; }
|
|
bool isLinkJob() const override { return true; }
|
|
|
|
void ConstructJob(Compilation &C, const JobAction &JA,
|
|
const InputInfo &Output, const InputInfoList &Inputs,
|
|
const llvm::opt::ArgList &TCArgs,
|
|
const char *LinkingOutput) const override;
|
|
};
|
|
} // end namespace gnutools
|
|
|
|
/// gcc - Generic GCC tool implementations.
|
|
namespace gcc {
|
|
class LLVM_LIBRARY_VISIBILITY Common : public Tool {
|
|
public:
|
|
Common(const char *Name, const char *ShortName, const ToolChain &TC)
|
|
: Tool(Name, ShortName, TC) {}
|
|
|
|
// A gcc tool has an "integrated" assembler that it will call to produce an
|
|
// object. Let it use that assembler so that we don't have to deal with
|
|
// assembly syntax incompatibilities.
|
|
bool hasIntegratedAssembler() const override { return true; }
|
|
void ConstructJob(Compilation &C, const JobAction &JA,
|
|
const InputInfo &Output, const InputInfoList &Inputs,
|
|
const llvm::opt::ArgList &TCArgs,
|
|
const char *LinkingOutput) const override;
|
|
|
|
/// RenderExtraToolArgs - Render any arguments necessary to force
|
|
/// the particular tool mode.
|
|
virtual void RenderExtraToolArgs(const JobAction &JA,
|
|
llvm::opt::ArgStringList &CmdArgs) const = 0;
|
|
};
|
|
|
|
class LLVM_LIBRARY_VISIBILITY Preprocessor : public Common {
|
|
public:
|
|
Preprocessor(const ToolChain &TC)
|
|
: Common("gcc::Preprocessor", "gcc preprocessor", TC) {}
|
|
|
|
bool hasGoodDiagnostics() const override { return true; }
|
|
bool hasIntegratedCPP() const override { return false; }
|
|
|
|
void RenderExtraToolArgs(const JobAction &JA,
|
|
llvm::opt::ArgStringList &CmdArgs) const override;
|
|
};
|
|
|
|
class LLVM_LIBRARY_VISIBILITY Compiler : public Common {
|
|
public:
|
|
Compiler(const ToolChain &TC) : Common("gcc::Compiler", "gcc frontend", TC) {}
|
|
|
|
bool hasGoodDiagnostics() const override { return true; }
|
|
bool hasIntegratedCPP() const override { return true; }
|
|
|
|
void RenderExtraToolArgs(const JobAction &JA,
|
|
llvm::opt::ArgStringList &CmdArgs) const override;
|
|
};
|
|
|
|
class LLVM_LIBRARY_VISIBILITY Linker : public Common {
|
|
public:
|
|
Linker(const ToolChain &TC) : Common("gcc::Linker", "linker (via gcc)", TC) {}
|
|
|
|
bool hasIntegratedCPP() const override { return false; }
|
|
bool isLinkJob() const override { return true; }
|
|
|
|
void RenderExtraToolArgs(const JobAction &JA,
|
|
llvm::opt::ArgStringList &CmdArgs) const override;
|
|
};
|
|
} // end namespace gcc
|
|
} // end namespace tools
|
|
|
|
namespace toolchains {
|
|
|
|
/// Generic_GCC - A tool chain using the 'gcc' command to perform
|
|
/// all subcommands; this relies on gcc translating the majority of
|
|
/// command line options.
|
|
class LLVM_LIBRARY_VISIBILITY Generic_GCC : public ToolChain {
|
|
public:
|
|
/// Struct to store and manipulate GCC versions.
|
|
///
|
|
/// We rely on assumptions about the form and structure of GCC version
|
|
/// numbers: they consist of at most three '.'-separated components, and each
|
|
/// component is a non-negative integer except for the last component. For
|
|
/// the last component we are very flexible in order to tolerate release
|
|
/// candidates or 'x' wildcards.
|
|
///
|
|
/// Note that the ordering established among GCCVersions is based on the
|
|
/// preferred version string to use. For example we prefer versions without
|
|
/// a hard-coded patch number to those with a hard coded patch number.
|
|
///
|
|
/// Currently this doesn't provide any logic for textual suffixes to patches
|
|
/// in the way that (for example) Debian's version format does. If that ever
|
|
/// becomes necessary, it can be added.
|
|
struct GCCVersion {
|
|
/// The unparsed text of the version.
|
|
std::string Text;
|
|
|
|
/// The parsed major, minor, and patch numbers.
|
|
int Major, Minor, Patch;
|
|
|
|
/// The text of the parsed major, and major+minor versions.
|
|
std::string MajorStr, MinorStr;
|
|
|
|
/// Any textual suffix on the patch number.
|
|
std::string PatchSuffix;
|
|
|
|
static GCCVersion Parse(StringRef VersionText);
|
|
bool isOlderThan(int RHSMajor, int RHSMinor, int RHSPatch,
|
|
StringRef RHSPatchSuffix = StringRef()) const;
|
|
bool operator<(const GCCVersion &RHS) const {
|
|
return isOlderThan(RHS.Major, RHS.Minor, RHS.Patch, RHS.PatchSuffix);
|
|
}
|
|
bool operator>(const GCCVersion &RHS) const { return RHS < *this; }
|
|
bool operator<=(const GCCVersion &RHS) const { return !(*this > RHS); }
|
|
bool operator>=(const GCCVersion &RHS) const { return !(*this < RHS); }
|
|
};
|
|
|
|
/// This is a class to find a viable GCC installation for Clang to
|
|
/// use.
|
|
///
|
|
/// This class tries to find a GCC installation on the system, and report
|
|
/// information about it. It starts from the host information provided to the
|
|
/// Driver, and has logic for fuzzing that where appropriate.
|
|
class GCCInstallationDetector {
|
|
bool IsValid;
|
|
llvm::Triple GCCTriple;
|
|
const Driver &D;
|
|
|
|
// FIXME: These might be better as path objects.
|
|
std::string GCCInstallPath;
|
|
std::string GCCParentLibPath;
|
|
|
|
/// The primary multilib appropriate for the given flags.
|
|
Multilib SelectedMultilib;
|
|
/// On Biarch systems, this corresponds to the default multilib when
|
|
/// targeting the non-default multilib. Otherwise, it is empty.
|
|
llvm::Optional<Multilib> BiarchSibling;
|
|
|
|
GCCVersion Version;
|
|
|
|
// We retain the list of install paths that were considered and rejected in
|
|
// order to print out detailed information in verbose mode.
|
|
std::set<std::string> CandidateGCCInstallPaths;
|
|
|
|
/// The set of multilibs that the detected installation supports.
|
|
MultilibSet Multilibs;
|
|
|
|
// Gentoo-specific toolchain configurations are stored here.
|
|
const std::string GentooConfigDir = "/etc/env.d/gcc";
|
|
|
|
public:
|
|
explicit GCCInstallationDetector(const Driver &D) : IsValid(false), D(D) {}
|
|
void init(const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args,
|
|
ArrayRef<std::string> ExtraTripleAliases = None);
|
|
|
|
/// Check whether we detected a valid GCC install.
|
|
bool isValid() const { return IsValid; }
|
|
|
|
/// Get the GCC triple for the detected install.
|
|
const llvm::Triple &getTriple() const { return GCCTriple; }
|
|
|
|
/// Get the detected GCC installation path.
|
|
StringRef getInstallPath() const { return GCCInstallPath; }
|
|
|
|
/// Get the detected GCC parent lib path.
|
|
StringRef getParentLibPath() const { return GCCParentLibPath; }
|
|
|
|
/// Get the detected Multilib
|
|
const Multilib &getMultilib() const { return SelectedMultilib; }
|
|
|
|
/// Get the whole MultilibSet
|
|
const MultilibSet &getMultilibs() const { return Multilibs; }
|
|
|
|
/// Get the biarch sibling multilib (if it exists).
|
|
/// \return true iff such a sibling exists
|
|
bool getBiarchSibling(Multilib &M) const;
|
|
|
|
/// Get the detected GCC version string.
|
|
const GCCVersion &getVersion() const { return Version; }
|
|
|
|
/// Print information about the detected GCC installation.
|
|
void print(raw_ostream &OS) const;
|
|
|
|
private:
|
|
static void
|
|
CollectLibDirsAndTriples(const llvm::Triple &TargetTriple,
|
|
const llvm::Triple &BiarchTriple,
|
|
SmallVectorImpl<StringRef> &LibDirs,
|
|
SmallVectorImpl<StringRef> &TripleAliases,
|
|
SmallVectorImpl<StringRef> &BiarchLibDirs,
|
|
SmallVectorImpl<StringRef> &BiarchTripleAliases);
|
|
|
|
void AddDefaultGCCPrefixes(const llvm::Triple &TargetTriple,
|
|
SmallVectorImpl<std::string> &Prefixes,
|
|
StringRef SysRoot);
|
|
|
|
bool ScanGCCForMultilibs(const llvm::Triple &TargetTriple,
|
|
const llvm::opt::ArgList &Args,
|
|
StringRef Path,
|
|
bool NeedsBiarchSuffix = false);
|
|
|
|
void ScanLibDirForGCCTriple(const llvm::Triple &TargetArch,
|
|
const llvm::opt::ArgList &Args,
|
|
const std::string &LibDir,
|
|
StringRef CandidateTriple,
|
|
bool NeedsBiarchSuffix, bool GCCDirExists,
|
|
bool GCCCrossDirExists);
|
|
|
|
bool ScanGentooConfigs(const llvm::Triple &TargetTriple,
|
|
const llvm::opt::ArgList &Args,
|
|
const SmallVectorImpl<StringRef> &CandidateTriples,
|
|
const SmallVectorImpl<StringRef> &BiarchTriples);
|
|
|
|
bool ScanGentooGccConfig(const llvm::Triple &TargetTriple,
|
|
const llvm::opt::ArgList &Args,
|
|
StringRef CandidateTriple,
|
|
bool NeedsBiarchSuffix = false);
|
|
};
|
|
|
|
protected:
|
|
GCCInstallationDetector GCCInstallation;
|
|
CudaInstallationDetector CudaInstallation;
|
|
RocmInstallationDetector RocmInstallation;
|
|
|
|
public:
|
|
Generic_GCC(const Driver &D, const llvm::Triple &Triple,
|
|
const llvm::opt::ArgList &Args);
|
|
~Generic_GCC() override;
|
|
|
|
void printVerboseInfo(raw_ostream &OS) const override;
|
|
|
|
bool IsUnwindTablesDefault(const llvm::opt::ArgList &Args) const override;
|
|
bool isPICDefault() const override;
|
|
bool isPIEDefault() const override;
|
|
bool isPICDefaultForced() const override;
|
|
bool IsIntegratedAssemblerDefault() const override;
|
|
llvm::opt::DerivedArgList *
|
|
TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
|
|
Action::OffloadKind DeviceOffloadKind) const override;
|
|
|
|
protected:
|
|
Tool *getTool(Action::ActionClass AC) const override;
|
|
Tool *buildAssembler() const override;
|
|
Tool *buildLinker() const override;
|
|
|
|
virtual std::string getMultiarchTriple(const Driver &D,
|
|
const llvm::Triple &TargetTriple,
|
|
StringRef SysRoot) const
|
|
{ return TargetTriple.str(); }
|
|
|
|
/// \name ToolChain Implementation Helper Functions
|
|
/// @{
|
|
|
|
/// Check whether the target triple's architecture is 64-bits.
|
|
bool isTarget64Bit() const { return getTriple().isArch64Bit(); }
|
|
|
|
/// Check whether the target triple's architecture is 32-bits.
|
|
bool isTarget32Bit() const { return getTriple().isArch32Bit(); }
|
|
|
|
void PushPPaths(ToolChain::path_list &PPaths);
|
|
void AddMultilibPaths(const Driver &D, const std::string &SysRoot,
|
|
const std::string &OSLibDir,
|
|
const std::string &MultiarchTriple,
|
|
path_list &Paths);
|
|
void AddMultiarchPaths(const Driver &D, const std::string &SysRoot,
|
|
const std::string &OSLibDir, path_list &Paths);
|
|
void AddMultilibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
|
|
llvm::opt::ArgStringList &CC1Args) const;
|
|
|
|
// FIXME: This should be final, but the CrossWindows toolchain does weird
|
|
// things that can't be easily generalized.
|
|
void AddClangCXXStdlibIncludeArgs(
|
|
const llvm::opt::ArgList &DriverArgs,
|
|
llvm::opt::ArgStringList &CC1Args) const override;
|
|
|
|
virtual void
|
|
addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
|
|
llvm::opt::ArgStringList &CC1Args) const;
|
|
virtual void
|
|
addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
|
|
llvm::opt::ArgStringList &CC1Args) const;
|
|
|
|
bool
|
|
addGCCLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
|
|
llvm::opt::ArgStringList &CC1Args) const;
|
|
|
|
bool addLibStdCXXIncludePaths(Twine Base, Twine Suffix, StringRef GCCTriple,
|
|
StringRef GCCMultiarchTriple,
|
|
StringRef TargetMultiarchTriple,
|
|
Twine IncludeSuffix,
|
|
const llvm::opt::ArgList &DriverArgs,
|
|
llvm::opt::ArgStringList &CC1Args) const;
|
|
|
|
/// @}
|
|
|
|
private:
|
|
mutable std::unique_ptr<tools::gcc::Preprocessor> Preprocess;
|
|
mutable std::unique_ptr<tools::gcc::Compiler> Compile;
|
|
};
|
|
|
|
class LLVM_LIBRARY_VISIBILITY Generic_ELF : public Generic_GCC {
|
|
virtual void anchor();
|
|
|
|
public:
|
|
Generic_ELF(const Driver &D, const llvm::Triple &Triple,
|
|
const llvm::opt::ArgList &Args)
|
|
: Generic_GCC(D, Triple, Args) {}
|
|
|
|
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
|
|
llvm::opt::ArgStringList &CC1Args,
|
|
Action::OffloadKind DeviceOffloadKind) const override;
|
|
|
|
virtual std::string getDynamicLinker(const llvm::opt::ArgList &Args) const {
|
|
return {};
|
|
}
|
|
|
|
virtual void addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const {}
|
|
};
|
|
|
|
} // end namespace toolchains
|
|
} // end namespace driver
|
|
} // end namespace clang
|
|
|
|
#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_GNU_H
|