clang/lib/Driver/ToolChains/CrossWindows.cpp - rust-lang/llvm-project - Git at Google

 //===-- CrossWindows.cpp - Cross Windows Tool Chain -----------------------===//
 //
 // 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 "CrossWindows.h"
 #include "CommonArgs.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/SanitizerArgs.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/Path.h"

 using namespace clang::driver;
 using namespace clang::driver::toolchains;

 using llvm::opt::ArgList;
 using llvm::opt::ArgStringList;

 void tools::CrossWindows::Assembler::ConstructJob(
     Compilation &C, const JobAction &JA, const InputInfo &Output,
     const InputInfoList &Inputs, const ArgList &Args,
     const char *LinkingOutput) const {
   claimNoWarnArgs(Args);
   const auto &TC =
       static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
   ArgStringList CmdArgs;
   const char *Exec;

   switch (TC.getArch()) {
   default:
     llvm_unreachable("unsupported architecture");
   case llvm::Triple::arm:
   case llvm::Triple::thumb:
   case llvm::Triple::aarch64:
     break;
   case llvm::Triple::x86:
     CmdArgs.push_back("--32");
     break;
   case llvm::Triple::x86_64:
     CmdArgs.push_back("--64");
     break;
   }

   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);

   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());

   for (const auto &Input : Inputs)
     CmdArgs.push_back(Input.getFilename());

   const std::string Assembler = TC.GetProgramPath("as");
   Exec = Args.MakeArgString(Assembler);

   C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
                                          Exec, CmdArgs, Inputs, Output));
 }

 void tools::CrossWindows::Linker::ConstructJob(
     Compilation &C, const JobAction &JA, const InputInfo &Output,
     const InputInfoList &Inputs, const ArgList &Args,
     const char *LinkingOutput) const {
   const auto &TC =
       static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
   const llvm::Triple &T = TC.getTriple();
   const Driver &D = TC.getDriver();
   SmallString<128> EntryPoint;
   ArgStringList CmdArgs;
   const char *Exec;

   // Silence warning for "clang -g foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_g_Group);
   // and "clang -emit-llvm foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_emit_llvm);
   // and for "clang -w foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_w);
   // Other warning options are already handled somewhere else.

   if (!D.SysRoot.empty())
     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));

   if (Args.hasArg(options::OPT_pie))
     CmdArgs.push_back("-pie");
   if (Args.hasArg(options::OPT_rdynamic))
     CmdArgs.push_back("-export-dynamic");
   if (Args.hasArg(options::OPT_s))
     CmdArgs.push_back("--strip-all");

   CmdArgs.push_back("-m");
   switch (TC.getArch()) {
   default:
     D.Diag(diag::err_target_unknown_triple) << TC.getEffectiveTriple().str();
     break;
   case llvm::Triple::arm:
   case llvm::Triple::thumb:
     // FIXME: this is incorrect for WinCE
     CmdArgs.push_back("thumb2pe");
     break;
   case llvm::Triple::aarch64:
     CmdArgs.push_back("arm64pe");
     break;
   case llvm::Triple::x86:
     CmdArgs.push_back("i386pe");
     EntryPoint.append("_");
     break;
   case llvm::Triple::x86_64:
     CmdArgs.push_back("i386pep");
     break;
   }

   if (Args.hasArg(options::OPT_shared)) {
     switch (T.getArch()) {
     default:
       llvm_unreachable("unsupported architecture");
     case llvm::Triple::aarch64:
     case llvm::Triple::arm:
     case llvm::Triple::thumb:
     case llvm::Triple::x86_64:
       EntryPoint.append("_DllMainCRTStartup");
       break;
     case llvm::Triple::x86:
       EntryPoint.append("_DllMainCRTStartup@12");
       break;
     }

     CmdArgs.push_back("-shared");
     CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
                                                        : "-Bdynamic");

     CmdArgs.push_back("--enable-auto-image-base");

     CmdArgs.push_back("--entry");
     CmdArgs.push_back(Args.MakeArgString(EntryPoint));
   } else {
     EntryPoint.append("mainCRTStartup");

     CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
                                                        : "-Bdynamic");

     if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
       CmdArgs.push_back("--entry");
       CmdArgs.push_back(Args.MakeArgString(EntryPoint));
     }

     // FIXME: handle subsystem
   }

   // NOTE: deal with multiple definitions on Windows (e.g. COMDAT)
   CmdArgs.push_back("--allow-multiple-definition");

   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());

   if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
     SmallString<261> ImpLib(Output.getFilename());
     llvm::sys::path::replace_extension(ImpLib, ".lib");

     CmdArgs.push_back("--out-implib");
     CmdArgs.push_back(Args.MakeArgString(ImpLib));
   }

   Args.AddAllArgs(CmdArgs, options::OPT_L);
   TC.AddFilePathLibArgs(Args, CmdArgs);
   AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);

   if (TC.ShouldLinkCXXStdlib(Args)) {
     bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
                      !Args.hasArg(options::OPT_static);
     if (StaticCXX)
       CmdArgs.push_back("-Bstatic");
     TC.AddCXXStdlibLibArgs(Args, CmdArgs);
     if (StaticCXX)
       CmdArgs.push_back("-Bdynamic");
   }

   if (!Args.hasArg(options::OPT_nostdlib)) {
     if (!Args.hasArg(options::OPT_nodefaultlibs)) {
       // TODO handle /MT[d] /MD[d]
       CmdArgs.push_back("-lmsvcrt");
       AddRunTimeLibs(TC, D, CmdArgs, Args);
     }
   }

   if (TC.getSanitizerArgs(Args).needsAsanRt()) {
     // TODO handle /MT[d] /MD[d]
     if (Args.hasArg(options::OPT_shared)) {
       CmdArgs.push_back(TC.getCompilerRTArgString(Args, "asan_dll_thunk"));
     } else {
       for (const auto &Lib : {"asan_dynamic", "asan_dynamic_runtime_thunk"})
         CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
       // Make sure the dynamic runtime thunk is not optimized out at link time
       // to ensure proper SEH handling.
       CmdArgs.push_back(Args.MakeArgString("--undefined"));
       CmdArgs.push_back(Args.MakeArgString(TC.getArch() == llvm::Triple::x86
                                                ? "___asan_seh_interceptor"
                                                : "__asan_seh_interceptor"));
     }
   }

   Exec = Args.MakeArgString(TC.GetLinkerPath());

   C.addCommand(std::make_unique<Command>(JA, *this,
                                          ResponseFileSupport::AtFileUTF8(),
                                          Exec, CmdArgs, Inputs, Output));
 }

 CrossWindowsToolChain::CrossWindowsToolChain(const Driver &D,
                                              const llvm::Triple &T,
                                              const llvm::opt::ArgList &Args)
     : Generic_GCC(D, T, Args) {}

 ToolChain::UnwindTableLevel
 CrossWindowsToolChain::getDefaultUnwindTableLevel(const ArgList &Args) const {
   // FIXME: all non-x86 targets need unwind tables, however, LLVM currently does
   // not know how to emit them.
   return getArch() == llvm::Triple::x86_64 ? UnwindTableLevel::Asynchronous : UnwindTableLevel::None;
 }

 bool CrossWindowsToolChain::isPICDefault() const {
   return getArch() == llvm::Triple::x86_64;
 }

 bool CrossWindowsToolChain::isPIEDefault(const llvm::opt::ArgList &Args) const {
   return getArch() == llvm::Triple::x86_64;
 }

 bool CrossWindowsToolChain::isPICDefaultForced() const {
   return getArch() == llvm::Triple::x86_64;
 }

 void CrossWindowsToolChain::
 AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                           llvm::opt::ArgStringList &CC1Args) const {
   const Driver &D = getDriver();
   const std::string &SysRoot = D.SysRoot;

   auto AddSystemAfterIncludes = [&]() {
     for (const auto &P : DriverArgs.getAllArgValues(options::OPT_isystem_after))
       addSystemInclude(DriverArgs, CC1Args, P);
   };

   if (DriverArgs.hasArg(options::OPT_nostdinc)) {
     AddSystemAfterIncludes();
     return;
   }

   addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
     SmallString<128> ResourceDir(D.ResourceDir);
     llvm::sys::path::append(ResourceDir, "include");
     addSystemInclude(DriverArgs, CC1Args, ResourceDir);
   }
   AddSystemAfterIncludes();
   addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
 }

 void CrossWindowsToolChain::
 AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                              llvm::opt::ArgStringList &CC1Args) const {
   const std::string &SysRoot = getDriver().SysRoot;

   if (DriverArgs.hasArg(options::OPT_nostdinc) ||
       DriverArgs.hasArg(options::OPT_nostdincxx))
     return;

   if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx)
     addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include/c++/v1");
 }

 void CrossWindowsToolChain::
 AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
                     llvm::opt::ArgStringList &CmdArgs) const {
   if (GetCXXStdlibType(Args) == ToolChain::CST_Libcxx) {
     CmdArgs.push_back("-lc++");
     if (Args.hasArg(options::OPT_fexperimental_library))
       CmdArgs.push_back("-lc++experimental");
   }
 }

 clang::SanitizerMask CrossWindowsToolChain::getSupportedSanitizers() const {
   SanitizerMask Res = ToolChain::getSupportedSanitizers();
   Res |= SanitizerKind::Address;
   Res |= SanitizerKind::PointerCompare;
   Res |= SanitizerKind::PointerSubtract;
   return Res;
 }

 Tool *CrossWindowsToolChain::buildLinker() const {
   return new tools::CrossWindows::Linker(*this);
 }

 Tool *CrossWindowsToolChain::buildAssembler() const {
   return new tools::CrossWindows::Assembler(*this);
 }
	//===-- CrossWindows.cpp - Cross Windows Tool Chain -----------------------===//
	//
	// 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 "CrossWindows.h"
	#include "CommonArgs.h"
	#include "clang/Driver/Compilation.h"
	#include "clang/Driver/Driver.h"
	#include "clang/Driver/Options.h"
	#include "clang/Driver/SanitizerArgs.h"
	#include "llvm/Option/ArgList.h"
	#include "llvm/Support/Path.h"

	using namespace clang::driver;
	using namespace clang::driver::toolchains;

	using llvm::opt::ArgList;
	using llvm::opt::ArgStringList;

	void tools::CrossWindows::Assembler::ConstructJob(
	Compilation &C, const JobAction &JA, const InputInfo &Output,
	const InputInfoList &Inputs, const ArgList &Args,
	const char *LinkingOutput) const {
	claimNoWarnArgs(Args);
	const auto &TC =
	static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
	ArgStringList CmdArgs;
	const char *Exec;

	switch (TC.getArch()) {
	default:
	llvm_unreachable("unsupported architecture");
	case llvm::Triple::arm:
	case llvm::Triple::thumb:
	case llvm::Triple::aarch64:
	break;
	case llvm::Triple::x86:
	CmdArgs.push_back("--32");
	break;
	case llvm::Triple::x86_64:
	CmdArgs.push_back("--64");
	break;
	}

	Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);

	CmdArgs.push_back("-o");
	CmdArgs.push_back(Output.getFilename());

	for (const auto &Input : Inputs)
	CmdArgs.push_back(Input.getFilename());

	const std::string Assembler = TC.GetProgramPath("as");
	Exec = Args.MakeArgString(Assembler);

	C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
	Exec, CmdArgs, Inputs, Output));
	}

	void tools::CrossWindows::Linker::ConstructJob(
	Compilation &C, const JobAction &JA, const InputInfo &Output,
	const InputInfoList &Inputs, const ArgList &Args,
	const char *LinkingOutput) const {
	const auto &TC =
	static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
	const llvm::Triple &T = TC.getTriple();
	const Driver &D = TC.getDriver();
	SmallString<128> EntryPoint;
	ArgStringList CmdArgs;
	const char *Exec;

	// Silence warning for "clang -g foo.o -o foo"
	Args.ClaimAllArgs(options::OPT_g_Group);
	// and "clang -emit-llvm foo.o -o foo"
	Args.ClaimAllArgs(options::OPT_emit_llvm);
	// and for "clang -w foo.o -o foo"
	Args.ClaimAllArgs(options::OPT_w);
	// Other warning options are already handled somewhere else.

	if (!D.SysRoot.empty())
	CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));

	if (Args.hasArg(options::OPT_pie))
	CmdArgs.push_back("-pie");
	if (Args.hasArg(options::OPT_rdynamic))
	CmdArgs.push_back("-export-dynamic");
	if (Args.hasArg(options::OPT_s))
	CmdArgs.push_back("--strip-all");

	CmdArgs.push_back("-m");
	switch (TC.getArch()) {
	default:
	D.Diag(diag::err_target_unknown_triple) << TC.getEffectiveTriple().str();
	break;
	case llvm::Triple::arm:
	case llvm::Triple::thumb:
	// FIXME: this is incorrect for WinCE
	CmdArgs.push_back("thumb2pe");
	break;
	case llvm::Triple::aarch64:
	CmdArgs.push_back("arm64pe");
	break;
	case llvm::Triple::x86:
	CmdArgs.push_back("i386pe");
	EntryPoint.append("_");
	break;
	case llvm::Triple::x86_64:
	CmdArgs.push_back("i386pep");
	break;
	}

	if (Args.hasArg(options::OPT_shared)) {
	switch (T.getArch()) {
	default:
	llvm_unreachable("unsupported architecture");
	case llvm::Triple::aarch64:
	case llvm::Triple::arm:
	case llvm::Triple::thumb:
	case llvm::Triple::x86_64:
	EntryPoint.append("_DllMainCRTStartup");
	break;
	case llvm::Triple::x86:
	EntryPoint.append("_DllMainCRTStartup@12");
	break;
	}

	CmdArgs.push_back("-shared");
	CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
	: "-Bdynamic");

	CmdArgs.push_back("--enable-auto-image-base");

	CmdArgs.push_back("--entry");
	CmdArgs.push_back(Args.MakeArgString(EntryPoint));
	} else {
	EntryPoint.append("mainCRTStartup");

	CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
	: "-Bdynamic");

	if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
	CmdArgs.push_back("--entry");
	CmdArgs.push_back(Args.MakeArgString(EntryPoint));
	}

	// FIXME: handle subsystem
	}

	// NOTE: deal with multiple definitions on Windows (e.g. COMDAT)
	CmdArgs.push_back("--allow-multiple-definition");

	CmdArgs.push_back("-o");
	CmdArgs.push_back(Output.getFilename());

	if (Args.hasArg(options::OPT_shared) \|\| Args.hasArg(options::OPT_rdynamic)) {
	SmallString<261> ImpLib(Output.getFilename());
	llvm::sys::path::replace_extension(ImpLib, ".lib");

	CmdArgs.push_back("--out-implib");
	CmdArgs.push_back(Args.MakeArgString(ImpLib));
	}

	Args.AddAllArgs(CmdArgs, options::OPT_L);
	TC.AddFilePathLibArgs(Args, CmdArgs);
	AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);

	if (TC.ShouldLinkCXXStdlib(Args)) {
	bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
	!Args.hasArg(options::OPT_static);
	if (StaticCXX)
	CmdArgs.push_back("-Bstatic");
	TC.AddCXXStdlibLibArgs(Args, CmdArgs);
	if (StaticCXX)
	CmdArgs.push_back("-Bdynamic");
	}

	if (!Args.hasArg(options::OPT_nostdlib)) {
	if (!Args.hasArg(options::OPT_nodefaultlibs)) {
	// TODO handle /MT[d] /MD[d]
	CmdArgs.push_back("-lmsvcrt");
	AddRunTimeLibs(TC, D, CmdArgs, Args);
	}
	}

	if (TC.getSanitizerArgs(Args).needsAsanRt()) {
	// TODO handle /MT[d] /MD[d]
	if (Args.hasArg(options::OPT_shared)) {
	CmdArgs.push_back(TC.getCompilerRTArgString(Args, "asan_dll_thunk"));
	} else {
	for (const auto &Lib : {"asan_dynamic", "asan_dynamic_runtime_thunk"})
	CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
	// Make sure the dynamic runtime thunk is not optimized out at link time
	// to ensure proper SEH handling.
	CmdArgs.push_back(Args.MakeArgString("--undefined"));
	CmdArgs.push_back(Args.MakeArgString(TC.getArch() == llvm::Triple::x86
	? "___asan_seh_interceptor"
	: "__asan_seh_interceptor"));
	}
	}

	Exec = Args.MakeArgString(TC.GetLinkerPath());

	C.addCommand(std::make_unique<Command>(JA, *this,
	ResponseFileSupport::AtFileUTF8(),
	Exec, CmdArgs, Inputs, Output));
	}

	CrossWindowsToolChain::CrossWindowsToolChain(const Driver &D,
	const llvm::Triple &T,
	const llvm::opt::ArgList &Args)
	: Generic_GCC(D, T, Args) {}

	ToolChain::UnwindTableLevel
	CrossWindowsToolChain::getDefaultUnwindTableLevel(const ArgList &Args) const {
	// FIXME: all non-x86 targets need unwind tables, however, LLVM currently does
	// not know how to emit them.
	return getArch() == llvm::Triple::x86_64 ? UnwindTableLevel::Asynchronous : UnwindTableLevel::None;
	}

	bool CrossWindowsToolChain::isPICDefault() const {
	return getArch() == llvm::Triple::x86_64;
	}

	bool CrossWindowsToolChain::isPIEDefault(const llvm::opt::ArgList &Args) const {
	return getArch() == llvm::Triple::x86_64;
	}

	bool CrossWindowsToolChain::isPICDefaultForced() const {
	return getArch() == llvm::Triple::x86_64;
	}

	void CrossWindowsToolChain::
	AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
	llvm::opt::ArgStringList &CC1Args) const {
	const Driver &D = getDriver();
	const std::string &SysRoot = D.SysRoot;

	auto AddSystemAfterIncludes = [&]() {
	for (const auto &P : DriverArgs.getAllArgValues(options::OPT_isystem_after))
	addSystemInclude(DriverArgs, CC1Args, P);
	};

	if (DriverArgs.hasArg(options::OPT_nostdinc)) {
	AddSystemAfterIncludes();
	return;
	}

	addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
	if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
	SmallString<128> ResourceDir(D.ResourceDir);
	llvm::sys::path::append(ResourceDir, "include");
	addSystemInclude(DriverArgs, CC1Args, ResourceDir);
	}
	AddSystemAfterIncludes();
	addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
	}

	void CrossWindowsToolChain::
	AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
	llvm::opt::ArgStringList &CC1Args) const {
	const std::string &SysRoot = getDriver().SysRoot;

	if (DriverArgs.hasArg(options::OPT_nostdinc) \|\|
	DriverArgs.hasArg(options::OPT_nostdincxx))
	return;

	if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx)
	addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include/c++/v1");
	}

	void CrossWindowsToolChain::
	AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
	llvm::opt::ArgStringList &CmdArgs) const {
	if (GetCXXStdlibType(Args) == ToolChain::CST_Libcxx) {
	CmdArgs.push_back("-lc++");
	if (Args.hasArg(options::OPT_fexperimental_library))
	CmdArgs.push_back("-lc++experimental");
	}
	}

	clang::SanitizerMask CrossWindowsToolChain::getSupportedSanitizers() const {
	SanitizerMask Res = ToolChain::getSupportedSanitizers();
	Res \|= SanitizerKind::Address;
	Res \|= SanitizerKind::PointerCompare;
	Res \|= SanitizerKind::PointerSubtract;
	return Res;
	}

	Tool *CrossWindowsToolChain::buildLinker() const {
	return new tools::CrossWindows::Linker(*this);
	}

	Tool *CrossWindowsToolChain::buildAssembler() const {
	return new tools::CrossWindows::Assembler(*this);
	}