//===--- CommonArgs.cpp - Args handling for multiple toolchains -*- 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 "CommonArgs.h" #include "Arch/AArch64.h" #include "Arch/ARM.h" #include "Arch/CSKY.h" #include "Arch/LoongArch.h" #include "Arch/M68k.h" #include "Arch/Mips.h" #include "Arch/PPC.h" #include "Arch/RISCV.h" #include "Arch/Sparc.h" #include "Arch/SystemZ.h" #include "Arch/VE.h" #include "Arch/X86.h" #include "HIPAMD.h" #include "Hexagon.h" #include "MSP430.h" #include "Solaris.h" #include "clang/Basic/CharInfo.h" #include "clang/Basic/CodeGenOptions.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/ObjCRuntime.h" #include "clang/Basic/Version.h" #include "clang/Config/config.h" #include "clang/Driver/Action.h" #include "clang/Driver/Compilation.h" #include "clang/Driver/Driver.h" #include "clang/Driver/DriverDiagnostic.h" #include "clang/Driver/InputInfo.h" #include "clang/Driver/Job.h" #include "clang/Driver/Options.h" #include "clang/Driver/SanitizerArgs.h" #include "clang/Driver/ToolChain.h" #include "clang/Driver/Util.h" #include "clang/Driver/XRayArgs.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallSet.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/Twine.h" #include "llvm/BinaryFormat/Magic.h" #include "llvm/Config/llvm-config.h" #include "llvm/Option/Arg.h" #include "llvm/Option/ArgList.h" #include "llvm/Option/Option.h" #include "llvm/Support/CodeGen.h" #include "llvm/Support/Compression.h" #include "llvm/Support/Debug.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/Path.h" #include "llvm/Support/Process.h" #include "llvm/Support/Program.h" #include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/Threading.h" #include "llvm/Support/VirtualFileSystem.h" #include "llvm/Support/YAMLParser.h" #include "llvm/TargetParser/Host.h" #include "llvm/TargetParser/PPCTargetParser.h" #include "llvm/TargetParser/TargetParser.h" #include <optional> usingnamespaceclang::driver; usingnamespaceclang::driver::tools; usingnamespaceclang; usingnamespacellvm::opt; static bool useFramePointerForTargetByDefault(const llvm::opt::ArgList &Args, const llvm::Triple &Triple) { … } static bool useLeafFramePointerForTargetByDefault(const llvm::Triple &Triple) { … } static bool mustUseNonLeafFramePointerForTarget(const llvm::Triple &Triple) { … } // True if a target-specific option requires the frame chain to be preserved, // even if new frame records are not created. static bool mustMaintainValidFrameChain(const llvm::opt::ArgList &Args, const llvm::Triple &Triple) { … } // True if a target-specific option causes -fno-omit-frame-pointer to also // cause frame records to be created in leaf functions. static bool framePointerImpliesLeafFramePointer(const llvm::opt::ArgList &Args, const llvm::Triple &Triple) { … } clang::CodeGenOptions::FramePointerKind getFramePointerKind(const llvm::opt::ArgList &Args, const llvm::Triple &Triple) { … } static void renderRpassOptions(const ArgList &Args, ArgStringList &CmdArgs, const StringRef PluginOptPrefix) { … } static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple, const InputInfo &Input, const InputInfo &Output, const StringRef PluginOptPrefix) { … } static void renderRemarksHotnessOptions(const ArgList &Args, ArgStringList &CmdArgs, const StringRef PluginOptPrefix) { … } static bool shouldIgnoreUnsupportedTargetFeature(const Arg &TargetFeatureArg, llvm::Triple T, StringRef Processor) { … } void tools::addPathIfExists(const Driver &D, const Twine &Path, ToolChain::path_list &Paths) { … } void tools::handleTargetFeaturesGroup(const Driver &D, const llvm::Triple &Triple, const ArgList &Args, std::vector<StringRef> &Features, OptSpecifier Group) { … } SmallVector<StringRef> tools::unifyTargetFeatures(ArrayRef<StringRef> Features) { … } void tools::addDirectoryList(const ArgList &Args, ArgStringList &CmdArgs, const char *ArgName, const char *EnvVar) { … } void tools::AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const ArgList &Args, ArgStringList &CmdArgs, const JobAction &JA) { … } void tools::addLinkerCompressDebugSectionsOption( const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) { … } void tools::AddTargetFeature(const ArgList &Args, std::vector<StringRef> &Features, OptSpecifier OnOpt, OptSpecifier OffOpt, StringRef FeatureName) { … } /// Get the (LLVM) name of the AMDGPU gpu we are targeting. static std::string getAMDGPUTargetGPU(const llvm::Triple &T, const ArgList &Args) { … } static std::string getLanaiTargetCPU(const ArgList &Args) { … } /// Get the (LLVM) name of the WebAssembly cpu we are targeting. static StringRef getWebAssemblyTargetCPU(const ArgList &Args) { … } std::string tools::getCPUName(const Driver &D, const ArgList &Args, const llvm::Triple &T, bool FromAs) { … } static void getWebAssemblyTargetFeatures(const Driver &D, const llvm::Triple &Triple, const ArgList &Args, std::vector<StringRef> &Features) { … } void tools::getTargetFeatures(const Driver &D, const llvm::Triple &Triple, const ArgList &Args, ArgStringList &CmdArgs, bool ForAS, bool IsAux) { … } llvm::StringRef tools::getLTOParallelism(const ArgList &Args, const Driver &D) { … } // PS4/PS5 uses -ffunction-sections and -fdata-sections by default. bool tools::isUseSeparateSections(const llvm::Triple &Triple) { … } bool tools::isTLSDESCEnabled(const ToolChain &TC, const llvm::opt::ArgList &Args) { … } void tools::addLTOOptions(const ToolChain &ToolChain, const ArgList &Args, ArgStringList &CmdArgs, const InputInfo &Output, const InputInfo &Input, bool IsThinLTO) { … } void tools::addOpenMPRuntimeLibraryPath(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) { … } void tools::addArchSpecificRPath(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) { … } bool tools::addOpenMPRuntime(const Compilation &C, ArgStringList &CmdArgs, const ToolChain &TC, const ArgList &Args, bool ForceStaticHostRuntime, bool IsOffloadingHost, bool GompNeedsRT) { … } void tools::addOpenMPHostOffloadingArgs(const Compilation &C, const JobAction &JA, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) { … } /// Add Fortran runtime libs void tools::addFortranRuntimeLibs(const ToolChain &TC, const ArgList &Args, llvm::opt::ArgStringList &CmdArgs) { … } void tools::addFortranRuntimeLibraryPath(const ToolChain &TC, const llvm::opt::ArgList &Args, ArgStringList &CmdArgs) { … } static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs, StringRef Sanitizer, bool IsShared, bool IsWhole) { … } // Tries to use a file with the list of dynamic symbols that need to be exported // from the runtime library. Returns true if the file was found. static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs, StringRef Sanitizer) { … } void tools::addAsNeededOption(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, bool as_needed) { … } void tools::linkSanitizerRuntimeDeps(const ToolChain &TC, const llvm::opt::ArgList &Args, ArgStringList &CmdArgs) { … } static void collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args, SmallVectorImpl<StringRef> &SharedRuntimes, SmallVectorImpl<StringRef> &StaticRuntimes, SmallVectorImpl<StringRef> &NonWholeStaticRuntimes, SmallVectorImpl<StringRef> &HelperStaticRuntimes, SmallVectorImpl<StringRef> &RequiredSymbols) { … } // Should be called before we add system libraries (C++ ABI, libstdc++/libc++, // C runtime, etc). Returns true if sanitizer system deps need to be linked in. bool tools::addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) { … } bool tools::addXRayRuntime(const ToolChain&TC, const ArgList &Args, ArgStringList &CmdArgs) { … } void tools::linkXRayRuntimeDeps(const ToolChain &TC, const llvm::opt::ArgList &Args, ArgStringList &CmdArgs) { … } bool tools::areOptimizationsEnabled(const ArgList &Args) { … } const char *tools::SplitDebugName(const JobAction &JA, const ArgList &Args, const InputInfo &Input, const InputInfo &Output) { … } void tools::SplitDebugInfo(const ToolChain &TC, Compilation &C, const Tool &T, const JobAction &JA, const ArgList &Args, const InputInfo &Output, const char *OutFile) { … } // Claim options we don't want to warn if they are unused. We do this for // options that build systems might add but are unused when assembling or only // running the preprocessor for example. void tools::claimNoWarnArgs(const ArgList &Args) { … } Arg *tools::getLastCSProfileGenerateArg(const ArgList &Args) { … } Arg *tools::getLastProfileUseArg(const ArgList &Args) { … } Arg *tools::getLastProfileSampleUseArg(const ArgList &Args) { … } const char *tools::RelocationModelName(llvm::Reloc::Model Model) { … } /// Parses the various -fpic/-fPIC/-fpie/-fPIE arguments. Then, /// smooshes them together with platform defaults, to decide whether /// this compile should be using PIC mode or not. Returns a tuple of /// (RelocationModel, PICLevel, IsPIE). std::tuple<llvm::Reloc::Model, unsigned, bool> tools::ParsePICArgs(const ToolChain &ToolChain, const ArgList &Args) { … } // `-falign-functions` indicates that the functions should be aligned to the // backend's preferred alignment. // // `-falign-functions=1` is the same as `-fno-align-functions`. // // The scalar `n` in `-falign-functions=n` must be an integral value between // [0, 65536]. If the value is not a power-of-two, it will be rounded up to // the nearest power-of-two. // // If we return `0`, the frontend will default to the backend's preferred // alignment. // // NOTE: icc only allows values between [0, 4096]. icc uses `-falign-functions` // to mean `-falign-functions=16`. GCC defaults to the backend's preferred // alignment. For unaligned functions, we default to the backend's preferred // alignment. unsigned tools::ParseFunctionAlignment(const ToolChain &TC, const ArgList &Args) { … } void tools::addDebugInfoKind( ArgStringList &CmdArgs, llvm::codegenoptions::DebugInfoKind DebugInfoKind) { … } // Convert an arg of the form "-gN" or "-ggdbN" or one of their aliases // to the corresponding DebugInfoKind. llvm::codegenoptions::DebugInfoKind tools::debugLevelToInfoKind(const Arg &A) { … } static unsigned ParseDebugDefaultVersion(const ToolChain &TC, const ArgList &Args) { … } unsigned tools::DwarfVersionNum(StringRef ArgValue) { … } const Arg *tools::getDwarfNArg(const ArgList &Args) { … } unsigned tools::getDwarfVersion(const ToolChain &TC, const llvm::opt::ArgList &Args) { … } void tools::AddAssemblerKPIC(const ToolChain &ToolChain, const ArgList &Args, ArgStringList &CmdArgs) { … } /// Determine whether Objective-C automated reference counting is /// enabled. bool tools::isObjCAutoRefCount(const ArgList &Args) { … } enum class LibGccType { … }; static LibGccType getLibGccType(const ToolChain &TC, const Driver &D, const ArgList &Args) { … } // Gcc adds libgcc arguments in various ways: // // gcc <none>: -lgcc --as-needed -lgcc_s --no-as-needed // g++ <none>: -lgcc_s -lgcc // gcc shared: -lgcc_s -lgcc // g++ shared: -lgcc_s -lgcc // gcc static: -lgcc -lgcc_eh // g++ static: -lgcc -lgcc_eh // gcc static-pie: -lgcc -lgcc_eh // g++ static-pie: -lgcc -lgcc_eh // // Also, certain targets need additional adjustments. static void AddUnwindLibrary(const ToolChain &TC, const Driver &D, ArgStringList &CmdArgs, const ArgList &Args) { … } static void AddLibgcc(const ToolChain &TC, const Driver &D, ArgStringList &CmdArgs, const ArgList &Args) { … } void tools::AddRunTimeLibs(const ToolChain &TC, const Driver &D, ArgStringList &CmdArgs, const ArgList &Args) { … } SmallString<128> tools::getStatsFileName(const llvm::opt::ArgList &Args, const InputInfo &Output, const InputInfo &Input, const Driver &D) { … } void tools::addMultilibFlag(bool Enabled, const StringRef Flag, Multilib::flags_list &Flags) { … } void tools::addX86AlignBranchArgs(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs, bool IsLTO, const StringRef PluginOptPrefix) { … } /// SDLSearch: Search for Static Device Library /// The search for SDL bitcode files is consistent with how static host /// libraries are discovered. That is, the -l option triggers a search for /// files in a set of directories called the LINKPATH. The host library search /// procedure looks for a specific filename in the LINKPATH. The filename for /// a host library is lib<libname>.a or lib<libname>.so. For SDLs, there is an /// ordered-set of filenames that are searched. We call this ordered-set of /// filenames as SEARCH-ORDER. Since an SDL can either be device-type specific, /// architecture specific, or generic across all architectures, a naming /// convention and search order is used where the file name embeds the /// architecture name <arch-name> (nvptx or amdgcn) and the GPU device type /// <device-name> such as sm_30 and gfx906. <device-name> is absent in case of /// device-independent SDLs. To reduce congestion in host library directories, /// the search first looks for files in the “libdevice” subdirectory. SDLs that /// are bc files begin with the prefix “lib”. /// /// Machine-code SDLs can also be managed as an archive (*.a file). The /// convention has been to use the prefix “lib”. To avoid confusion with host /// archive libraries, we use prefix "libbc-" for the bitcode SDL archives. /// static bool SDLSearch(const Driver &D, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const SmallVectorImpl<std::string> &LibraryPaths, StringRef Lib, StringRef Arch, StringRef Target, bool isBitCodeSDL) { … } /// Search if a user provided archive file lib<libname>.a exists in any of /// the library paths. If so, add a new command to clang-offload-bundler to /// unbundle this archive and create a temporary device specific archive. Name /// of this SDL is passed to the llvm-link tool. static void GetSDLFromOffloadArchive( Compilation &C, const Driver &D, const Tool &T, const JobAction &JA, const InputInfoList &Inputs, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const SmallVectorImpl<std::string> &LibraryPaths, StringRef Lib, StringRef Arch, StringRef Target, bool isBitCodeSDL) { … } // Wrapper function used by driver for adding SDLs during link phase. void tools::AddStaticDeviceLibsLinking(Compilation &C, const Tool &T, const JobAction &JA, const InputInfoList &Inputs, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, StringRef Arch, StringRef Target, bool isBitCodeSDL) { … } // User defined Static Device Libraries(SDLs) can be passed to clang for // offloading GPU compilers. Like static host libraries, the use of a SDL is // specified with the -l command line option. The primary difference between // host and SDLs is the filenames for SDLs (refer SEARCH-ORDER for Bitcode SDLs // and SEARCH-ORDER for Machine-code SDLs for the naming convention). // SDLs are of following types: // // * Bitcode SDLs: They can either be a *.bc file or an archive of *.bc files. // For NVPTX, these libraries are post-clang linked following each // compilation. For AMDGPU, these libraries are linked one time // during the application link phase. // // * Machine-code SDLs: They are archive files. For AMDGPU, the process for // machine code SDLs is still in development. But they will be linked // by the LLVM tool lld. // // * Bundled objects that contain both host and device codes: Bundled objects // may also contain library code compiled from source. For NVPTX, the // bundle contains cubin. For AMDGPU, the bundle contains bitcode. // // For Bitcode and Machine-code SDLs, current compiler toolchains hardcode the // inclusion of specific SDLs such as math libraries and the OpenMP device // library libomptarget. void tools::AddStaticDeviceLibs(Compilation *C, const Tool *T, const JobAction *JA, const InputInfoList *Inputs, const Driver &D, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, StringRef Arch, StringRef Target, bool isBitCodeSDL) { … } static llvm::opt::Arg * getAMDGPUCodeObjectArgument(const Driver &D, const llvm::opt::ArgList &Args) { … } void tools::checkAMDGPUCodeObjectVersion(const Driver &D, const llvm::opt::ArgList &Args) { … } unsigned tools::getAMDGPUCodeObjectVersion(const Driver &D, const llvm::opt::ArgList &Args) { … } bool tools::haveAMDGPUCodeObjectVersionArgument( const Driver &D, const llvm::opt::ArgList &Args) { … } void tools::addMachineOutlinerArgs(const Driver &D, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const llvm::Triple &Triple, bool IsLTO, const StringRef PluginOptPrefix) { … } void tools::addOpenMPDeviceRTL(const Driver &D, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, StringRef BitcodeSuffix, const llvm::Triple &Triple, const ToolChain &HostTC) { … } void tools::addHIPRuntimeLibArgs(const ToolChain &TC, Compilation &C, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) { … } void tools::addOutlineAtomicsArgs(const Driver &D, const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const llvm::Triple &Triple) { … } void tools::addOffloadCompressArgs(const llvm::opt::ArgList &TCArgs, llvm::opt::ArgStringList &CmdArgs) { … } void tools::addMCModel(const Driver &D, const llvm::opt::ArgList &Args, const llvm::Triple &Triple, const llvm::Reloc::Model &RelocationModel, llvm::opt::ArgStringList &CmdArgs) { … } void tools::handleColorDiagnosticsArgs(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs) { … }
Codebase Browser
llvm