a42bb8b57a
This patch moves the CommonArgs utilities into a location visible by the Frontend Drivers, so that the Frontend Drivers may share option parsing code with the Compiler Driver. This is useful when the Frontend Drivers would like to verify that their incoming options are well-formed and also not reinvent the option parsing wheel. We already see code in the Clang/Flang Drivers that is parsing and verifying its incoming options. E.g. OPT_ffp_contract. This option is parsed in the Compiler Driver, Clang Driver, and Flang Driver, all with slightly different parsing code. It would be nice if the Frontend Drivers were not required to duplicate this Compiler Driver code. That way there is no/low maintenance burden on keeping all these parsing functions in sync. Along those lines, the Frontend Drivers will now have a useful mechanism to verify their incoming options are well-formed. Currently, the Frontend Drivers trust that the Compiler Driver is not passing back junk in some cases. The Language Drivers may even accept junk with no error at all. E.g.: `clang -cc1 -mprefer-vector-width=junk test.c' With this patch, we'll now be able to tighten up incomming options to the Frontend drivers in a lightweight way. --------- Co-authored-by: Cameron McInally <cmcinally@nvidia.com> Co-authored-by: Shafik Yaghmour <shafik.yaghmour@intel.com>
300 lines
9.8 KiB
C++
300 lines
9.8 KiB
C++
//===-- 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 "clang/Driver/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);
|
|
}
|