llvm/clang/lib/Driver/ToolChains/Linux.cpp

//===--- Linux.h - Linux 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
//
//===----------------------------------------------------------------------===//

#include "Linux.h"
#include "Arch/ARM.h"
#include "Arch/LoongArch.h"
#include "Arch/Mips.h"
#include "Arch/PPC.h"
#include "Arch/RISCV.h"
#include "CommonArgs.h"
#include "clang/Config/config.h"
#include "clang/Driver/Distro.h"
#include "clang/Driver/Driver.h"
#include "clang/Driver/Options.h"
#include "clang/Driver/SanitizerArgs.h"
#include "llvm/Option/ArgList.h"
#include "llvm/ProfileData/InstrProf.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/ScopedPrinter.h"
#include "llvm/Support/VirtualFileSystem.h"
#include <system_error>

usingnamespaceclang::driver;
usingnamespaceclang::driver::toolchains;
usingnamespaceclang;
usingnamespacellvm::opt;

addPathIfExists;

/// Get our best guess at the multiarch triple for a target.
///
/// Debian-based systems are starting to use a multiarch setup where they use
/// a target-triple directory in the library and header search paths.
/// Unfortunately, this triple does not align with the vanilla target triple,
/// so we provide a rough mapping here.
std::string Linux::getMultiarchTriple(const Driver &D,
                                      const llvm::Triple &TargetTriple,
                                      StringRef SysRoot) const { … }

static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) { … }

Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
    : … { … }

ToolChain::RuntimeLibType Linux::GetDefaultRuntimeLibType() const { … }

unsigned Linux::GetDefaultDwarfVersion() const { … }

ToolChain::CXXStdlibType Linux::GetDefaultCXXStdlibType() const { … }

bool Linux::HasNativeLLVMSupport() const { … }

Tool *Linux::buildLinker() const { … }

Tool *Linux::buildStaticLibTool() const { … }

Tool *Linux::buildAssembler() const { … }

std::string Linux::computeSysRoot() const { … }

std::string Linux::getDynamicLinker(const ArgList &Args) const { … }

void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
                                      ArgStringList &CC1Args) const { … }

void Linux::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
                                     llvm::opt::ArgStringList &CC1Args) const { … }

void Linux::AddCudaIncludeArgs(const ArgList &DriverArgs,
                               ArgStringList &CC1Args) const { … }

void Linux::AddHIPIncludeArgs(const ArgList &DriverArgs,
                              ArgStringList &CC1Args) const { … }

void Linux::AddHIPRuntimeLibArgs(const ArgList &Args,
                                 ArgStringList &CmdArgs) const { … }

void Linux::AddIAMCUIncludeArgs(const ArgList &DriverArgs,
                                ArgStringList &CC1Args) const { … }

bool Linux::isPIEDefault(const llvm::opt::ArgList &Args) const { … }

bool Linux::IsAArch64OutlineAtomicsDefault(const ArgList &Args) const { … }

bool Linux::IsMathErrnoDefault() const { … }

SanitizerMask Linux::getSupportedSanitizers() const { … }

void Linux::addProfileRTLibs(const llvm::opt::ArgList &Args,
                             llvm::opt::ArgStringList &CmdArgs) const { … }

void Linux::addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const { … }

const char *Linux::getDefaultLinker() const { … }