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

//===--- WebAssembly.cpp - WebAssembly ToolChain Implementation -*- 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 "WebAssembly.h"
#include "CommonArgs.h"
#include "Gnu.h"
#include "clang/Basic/Version.h"
#include "clang/Config/config.h"
#include "clang/Driver/Compilation.h"
#include "clang/Driver/Driver.h"
#include "clang/Driver/DriverDiagnostic.h"
#include "clang/Driver/Options.h"
#include "llvm/Config/llvm-config.h" // for LLVM_VERSION_STRING
#include "llvm/Option/ArgList.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/VirtualFileSystem.h"

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

/// Following the conventions in https://wiki.debian.org/Multiarch/Tuples,
/// we remove the vendor field to form the multiarch triple.
std::string WebAssembly::getMultiarchTriple(const Driver &D,
                                            const llvm::Triple &TargetTriple,
                                            StringRef SysRoot) const { … }

std::string wasm::Linker::getLinkerPath(const ArgList &Args) const { … }

static bool TargetBuildsComponents(const llvm::Triple &TargetTriple) { … }

void wasm::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                const InputInfo &Output,
                                const InputInfoList &Inputs,
                                const ArgList &Args,
                                const char *LinkingOutput) const { … }

/// Given a base library directory, append path components to form the
/// LTO directory.
static std::string AppendLTOLibDir(const std::string &Dir) { … }

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

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

bool WebAssembly::IsMathErrnoDefault() const { … }

bool WebAssembly::IsObjCNonFragileABIDefault() const { … }

bool WebAssembly::UseObjCMixedDispatch() const { … }

bool WebAssembly::isPICDefault() const { … }

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

bool WebAssembly::isPICDefaultForced() const { … }

bool WebAssembly::hasBlocksRuntime() const { … }

// TODO: Support profiling.
bool WebAssembly::SupportsProfiling() const { … }

bool WebAssembly::HasNativeLLVMSupport() const { … }

void WebAssembly::addClangTargetOptions(const ArgList &DriverArgs,
                                        ArgStringList &CC1Args,
                                        Action::OffloadKind) const { … }

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

ToolChain::CXXStdlibType
WebAssembly::GetCXXStdlibType(const ArgList &Args) const { … }

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

void WebAssembly::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
                                               ArgStringList &CC1Args) const { … }

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

SanitizerMask WebAssembly::getSupportedSanitizers() const { … }

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

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

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