| 1 | //===--- Driver.h - Clang GCC Compatible Driver -----------------*- C++ -*-===// |
|---|---|
| 2 | // |
| 3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 | // See https://llvm.org/LICENSE.txt for license information. |
| 5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 | // |
| 7 | //===----------------------------------------------------------------------===// |
| 8 | |
| 9 | #ifndef LLVM_CLANG_DRIVER_DRIVER_H |
| 10 | #define LLVM_CLANG_DRIVER_DRIVER_H |
| 11 | |
| 12 | #include "clang/Basic/Diagnostic.h" |
| 13 | #include "clang/Basic/LLVM.h" |
| 14 | #include "clang/Driver/Action.h" |
| 15 | #include "clang/Driver/Phases.h" |
| 16 | #include "clang/Driver/ToolChain.h" |
| 17 | #include "clang/Driver/Types.h" |
| 18 | #include "clang/Driver/Util.h" |
| 19 | #include "llvm/ADT/StringMap.h" |
| 20 | #include "llvm/ADT/StringRef.h" |
| 21 | #include "llvm/Option/ArgList.h" |
| 22 | #include "llvm/Support/StringSaver.h" |
| 23 | |
| 24 | #include <list> |
| 25 | #include <map> |
| 26 | #include <string> |
| 27 | |
| 28 | namespace llvm { |
| 29 | class Triple; |
| 30 | namespace vfs { |
| 31 | class FileSystem; |
| 32 | } |
| 33 | } // namespace llvm |
| 34 | |
| 35 | namespace clang { |
| 36 | |
| 37 | namespace driver { |
| 38 | |
| 39 | class Command; |
| 40 | class Compilation; |
| 41 | class InputInfo; |
| 42 | class JobList; |
| 43 | class JobAction; |
| 44 | class SanitizerArgs; |
| 45 | class ToolChain; |
| 46 | |
| 47 | /// Describes the kind of LTO mode selected via -f(no-)?lto(=.*)? options. |
| 48 | enum LTOKind { |
| 49 | LTOK_None, |
| 50 | LTOK_Full, |
| 51 | LTOK_Thin, |
| 52 | LTOK_Unknown |
| 53 | }; |
| 54 | |
| 55 | /// Driver - Encapsulate logic for constructing compilation processes |
| 56 | /// from a set of gcc-driver-like command line arguments. |
| 57 | class Driver { |
| 58 | std::unique_ptr<llvm::opt::OptTable> Opts; |
| 59 | |
| 60 | DiagnosticsEngine &Diags; |
| 61 | |
| 62 | IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS; |
| 63 | |
| 64 | enum DriverMode { |
| 65 | GCCMode, |
| 66 | GXXMode, |
| 67 | CPPMode, |
| 68 | CLMode |
| 69 | } Mode; |
| 70 | |
| 71 | enum SaveTempsMode { |
| 72 | SaveTempsNone, |
| 73 | SaveTempsCwd, |
| 74 | SaveTempsObj |
| 75 | } SaveTemps; |
| 76 | |
| 77 | enum BitcodeEmbedMode { |
| 78 | EmbedNone, |
| 79 | EmbedMarker, |
| 80 | EmbedBitcode |
| 81 | } BitcodeEmbed; |
| 82 | |
| 83 | /// LTO mode selected via -f(no-)?lto(=.*)? options. |
| 84 | LTOKind LTOMode; |
| 85 | |
| 86 | public: |
| 87 | enum OpenMPRuntimeKind { |
| 88 | /// An unknown OpenMP runtime. We can't generate effective OpenMP code |
| 89 | /// without knowing what runtime to target. |
| 90 | OMPRT_Unknown, |
| 91 | |
| 92 | /// The LLVM OpenMP runtime. When completed and integrated, this will become |
| 93 | /// the default for Clang. |
| 94 | OMPRT_OMP, |
| 95 | |
| 96 | /// The GNU OpenMP runtime. Clang doesn't support generating OpenMP code for |
| 97 | /// this runtime but can swallow the pragmas, and find and link against the |
| 98 | /// runtime library itself. |
| 99 | OMPRT_GOMP, |
| 100 | |
| 101 | /// The legacy name for the LLVM OpenMP runtime from when it was the Intel |
| 102 | /// OpenMP runtime. We support this mode for users with existing |
| 103 | /// dependencies on this runtime library name. |
| 104 | OMPRT_IOMP5 |
| 105 | }; |
| 106 | |
| 107 | // Diag - Forwarding function for diagnostics. |
| 108 | DiagnosticBuilder Diag(unsigned DiagID) const { |
| 109 | return Diags.Report(DiagID); |
| 110 | } |
| 111 | |
| 112 | // FIXME: Privatize once interface is stable. |
| 113 | public: |
| 114 | /// The name the driver was invoked as. |
| 115 | std::string Name; |
| 116 | |
| 117 | /// The path the driver executable was in, as invoked from the |
| 118 | /// command line. |
| 119 | std::string Dir; |
| 120 | |
| 121 | /// The original path to the clang executable. |
| 122 | std::string ClangExecutable; |
| 123 | |
| 124 | /// Target and driver mode components extracted from clang executable name. |
| 125 | ParsedClangName ClangNameParts; |
| 126 | |
| 127 | /// The path to the installed clang directory, if any. |
| 128 | std::string InstalledDir; |
| 129 | |
| 130 | /// The path to the compiler resource directory. |
| 131 | std::string ResourceDir; |
| 132 | |
| 133 | /// System directory for config files. |
| 134 | std::string SystemConfigDir; |
| 135 | |
| 136 | /// User directory for config files. |
| 137 | std::string UserConfigDir; |
| 138 | |
| 139 | /// A prefix directory used to emulate a limited subset of GCC's '-Bprefix' |
| 140 | /// functionality. |
| 141 | /// FIXME: This type of customization should be removed in favor of the |
| 142 | /// universal driver when it is ready. |
| 143 | typedef SmallVector<std::string, 4> prefix_list; |
| 144 | prefix_list PrefixDirs; |
| 145 | |
| 146 | /// sysroot, if present |
| 147 | std::string SysRoot; |
| 148 | |
| 149 | /// Dynamic loader prefix, if present |
| 150 | std::string DyldPrefix; |
| 151 | |
| 152 | /// Driver title to use with help. |
| 153 | std::string DriverTitle; |
| 154 | |
| 155 | /// Information about the host which can be overridden by the user. |
| 156 | std::string HostBits, HostMachine, HostSystem, HostRelease; |
| 157 | |
| 158 | /// The file to log CC_PRINT_OPTIONS output to, if enabled. |
| 159 | const char *CCPrintOptionsFilename; |
| 160 | |
| 161 | /// The file to log CC_PRINT_HEADERS output to, if enabled. |
| 162 | const char *CCPrintHeadersFilename; |
| 163 | |
| 164 | /// The file to log CC_LOG_DIAGNOSTICS output to, if enabled. |
| 165 | const char *CCLogDiagnosticsFilename; |
| 166 | |
| 167 | /// A list of inputs and their types for the given arguments. |
| 168 | typedef SmallVector<std::pair<types::ID, const llvm::opt::Arg *>, 16> |
| 169 | InputList; |
| 170 | |
| 171 | /// Whether the driver should follow g++ like behavior. |
| 172 | bool CCCIsCXX() const { return Mode == GXXMode; } |
| 173 | |
| 174 | /// Whether the driver is just the preprocessor. |
| 175 | bool CCCIsCPP() const { return Mode == CPPMode; } |
| 176 | |
| 177 | /// Whether the driver should follow gcc like behavior. |
| 178 | bool CCCIsCC() const { return Mode == GCCMode; } |
| 179 | |
| 180 | /// Whether the driver should follow cl.exe like behavior. |
| 181 | bool IsCLMode() const { return Mode == CLMode; } |
| 182 | |
| 183 | /// Only print tool bindings, don't build any jobs. |
| 184 | unsigned CCCPrintBindings : 1; |
| 185 | |
| 186 | /// Set CC_PRINT_OPTIONS mode, which is like -v but logs the commands to |
| 187 | /// CCPrintOptionsFilename or to stderr. |
| 188 | unsigned CCPrintOptions : 1; |
| 189 | |
| 190 | /// Set CC_PRINT_HEADERS mode, which causes the frontend to log header include |
| 191 | /// information to CCPrintHeadersFilename or to stderr. |
| 192 | unsigned CCPrintHeaders : 1; |
| 193 | |
| 194 | /// Set CC_LOG_DIAGNOSTICS mode, which causes the frontend to log diagnostics |
| 195 | /// to CCLogDiagnosticsFilename or to stderr, in a stable machine readable |
| 196 | /// format. |
| 197 | unsigned CCLogDiagnostics : 1; |
| 198 | |
| 199 | /// Whether the driver is generating diagnostics for debugging purposes. |
| 200 | unsigned CCGenDiagnostics : 1; |
| 201 | |
| 202 | private: |
| 203 | /// Raw target triple. |
| 204 | std::string TargetTriple; |
| 205 | |
| 206 | /// Name to use when invoking gcc/g++. |
| 207 | std::string CCCGenericGCCName; |
| 208 | |
| 209 | /// Name of configuration file if used. |
| 210 | std::string ConfigFile; |
| 211 | |
| 212 | /// Allocator for string saver. |
| 213 | llvm::BumpPtrAllocator Alloc; |
| 214 | |
| 215 | /// Object that stores strings read from configuration file. |
| 216 | llvm::StringSaver Saver; |
| 217 | |
| 218 | /// Arguments originated from configuration file. |
| 219 | std::unique_ptr<llvm::opt::InputArgList> CfgOptions; |
| 220 | |
| 221 | /// Arguments originated from command line. |
| 222 | std::unique_ptr<llvm::opt::InputArgList> CLOptions; |
| 223 | |
| 224 | /// Whether to check that input files exist when constructing compilation |
| 225 | /// jobs. |
| 226 | unsigned CheckInputsExist : 1; |
| 227 | |
| 228 | public: |
| 229 | /// Force clang to emit reproducer for driver invocation. This is enabled |
| 230 | /// indirectly by setting FORCE_CLANG_DIAGNOSTICS_CRASH environment variable |
| 231 | /// or when using the -gen-reproducer driver flag. |
| 232 | unsigned GenReproducer : 1; |
| 233 | |
| 234 | private: |
| 235 | /// Certain options suppress the 'no input files' warning. |
| 236 | unsigned SuppressMissingInputWarning : 1; |
| 237 | |
| 238 | std::list<std::string> TempFiles; |
| 239 | std::list<std::string> ResultFiles; |
| 240 | |
| 241 | /// Cache of all the ToolChains in use by the driver. |
| 242 | /// |
| 243 | /// This maps from the string representation of a triple to a ToolChain |
| 244 | /// created targeting that triple. The driver owns all the ToolChain objects |
| 245 | /// stored in it, and will clean them up when torn down. |
| 246 | mutable llvm::StringMap<std::unique_ptr<ToolChain>> ToolChains; |
| 247 | |
| 248 | private: |
| 249 | /// TranslateInputArgs - Create a new derived argument list from the input |
| 250 | /// arguments, after applying the standard argument translations. |
| 251 | llvm::opt::DerivedArgList * |
| 252 | TranslateInputArgs(const llvm::opt::InputArgList &Args) const; |
| 253 | |
| 254 | // getFinalPhase - Determine which compilation mode we are in and record |
| 255 | // which option we used to determine the final phase. |
| 256 | phases::ID getFinalPhase(const llvm::opt::DerivedArgList &DAL, |
| 257 | llvm::opt::Arg **FinalPhaseArg = nullptr) const; |
| 258 | |
| 259 | // Before executing jobs, sets up response files for commands that need them. |
| 260 | void setUpResponseFiles(Compilation &C, Command &Cmd); |
| 261 | |
| 262 | void generatePrefixedToolNames(StringRef Tool, const ToolChain &TC, |
| 263 | SmallVectorImpl<std::string> &Names) const; |
| 264 | |
| 265 | /// Find the appropriate .crash diagonostic file for the child crash |
| 266 | /// under this driver and copy it out to a temporary destination with the |
| 267 | /// other reproducer related files (.sh, .cache, etc). If not found, suggest a |
| 268 | /// directory for the user to look at. |
| 269 | /// |
| 270 | /// \param ReproCrashFilename The file path to copy the .crash to. |
| 271 | /// \param CrashDiagDir The suggested directory for the user to look at |
| 272 | /// in case the search or copy fails. |
| 273 | /// |
| 274 | /// \returns If the .crash is found and successfully copied return true, |
| 275 | /// otherwise false and return the suggested directory in \p CrashDiagDir. |
| 276 | bool getCrashDiagnosticFile(StringRef ReproCrashFilename, |
| 277 | SmallString<128> &CrashDiagDir); |
| 278 | |
| 279 | public: |
| 280 | |
| 281 | /// Takes the path to a binary that's either in bin/ or lib/ and returns |
| 282 | /// the path to clang's resource directory. |
| 283 | static std::string GetResourcesPath(StringRef BinaryPath, |
| 284 | StringRef CustomResourceDir = ""); |
| 285 | |
| 286 | Driver(StringRef ClangExecutable, StringRef TargetTriple, |
| 287 | DiagnosticsEngine &Diags, |
| 288 | IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS = nullptr); |
| 289 | |
| 290 | /// @name Accessors |
| 291 | /// @{ |
| 292 | |
| 293 | /// Name to use when invoking gcc/g++. |
| 294 | const std::string &getCCCGenericGCCName() const { return CCCGenericGCCName; } |
| 295 | |
| 296 | const std::string &getConfigFile() const { return ConfigFile; } |
| 297 | |
| 298 | const llvm::opt::OptTable &getOpts() const { return *Opts; } |
| 299 | |
| 300 | const DiagnosticsEngine &getDiags() const { return Diags; } |
| 301 | |
| 302 | llvm::vfs::FileSystem &getVFS() const { return *VFS; } |
| 303 | |
| 304 | bool getCheckInputsExist() const { return CheckInputsExist; } |
| 305 | |
| 306 | void setCheckInputsExist(bool Value) { CheckInputsExist = Value; } |
| 307 | |
| 308 | void setTargetAndMode(const ParsedClangName &TM) { ClangNameParts = TM; } |
| 309 | |
| 310 | const std::string &getTitle() { return DriverTitle; } |
| 311 | void setTitle(std::string Value) { DriverTitle = std::move(Value); } |
| 312 | |
| 313 | std::string getTargetTriple() const { return TargetTriple; } |
| 314 | |
| 315 | /// Get the path to the main clang executable. |
| 316 | const char *getClangProgramPath() const { |
| 317 | return ClangExecutable.c_str(); |
| 318 | } |
| 319 | |
| 320 | /// Get the path to where the clang executable was installed. |
| 321 | const char *getInstalledDir() const { |
| 322 | if (!InstalledDir.empty()) |
| 323 | return InstalledDir.c_str(); |
| 324 | return Dir.c_str(); |
| 325 | } |
| 326 | void setInstalledDir(StringRef Value) { |
| 327 | InstalledDir = Value; |
| 328 | } |
| 329 | |
| 330 | bool isSaveTempsEnabled() const { return SaveTemps != SaveTempsNone; } |
| 331 | bool isSaveTempsObj() const { return SaveTemps == SaveTempsObj; } |
| 332 | |
| 333 | bool embedBitcodeEnabled() const { return BitcodeEmbed != EmbedNone; } |
| 334 | bool embedBitcodeInObject() const { return (BitcodeEmbed == EmbedBitcode); } |
| 335 | bool embedBitcodeMarkerOnly() const { return (BitcodeEmbed == EmbedMarker); } |
| 336 | |
| 337 | /// Compute the desired OpenMP runtime from the flags provided. |
| 338 | OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const; |
| 339 | |
| 340 | /// @} |
| 341 | /// @name Primary Functionality |
| 342 | /// @{ |
| 343 | |
| 344 | /// CreateOffloadingDeviceToolChains - create all the toolchains required to |
| 345 | /// support offloading devices given the programming models specified in the |
| 346 | /// current compilation. Also, update the host tool chain kind accordingly. |
| 347 | void CreateOffloadingDeviceToolChains(Compilation &C, InputList &Inputs); |
| 348 | |
| 349 | /// BuildCompilation - Construct a compilation object for a command |
| 350 | /// line argument vector. |
| 351 | /// |
| 352 | /// \return A compilation, or 0 if none was built for the given |
| 353 | /// argument vector. A null return value does not necessarily |
| 354 | /// indicate an error condition, the diagnostics should be queried |
| 355 | /// to determine if an error occurred. |
| 356 | Compilation *BuildCompilation(ArrayRef<const char *> Args); |
| 357 | |
| 358 | /// @name Driver Steps |
| 359 | /// @{ |
| 360 | |
| 361 | /// ParseDriverMode - Look for and handle the driver mode option in Args. |
| 362 | void ParseDriverMode(StringRef ProgramName, ArrayRef<const char *> Args); |
| 363 | |
| 364 | /// ParseArgStrings - Parse the given list of strings into an |
| 365 | /// ArgList. |
| 366 | llvm::opt::InputArgList ParseArgStrings(ArrayRef<const char *> Args, |
| 367 | bool IsClCompatMode, |
| 368 | bool &ContainsError); |
| 369 | |
| 370 | /// BuildInputs - Construct the list of inputs and their types from |
| 371 | /// the given arguments. |
| 372 | /// |
| 373 | /// \param TC - The default host tool chain. |
| 374 | /// \param Args - The input arguments. |
| 375 | /// \param Inputs - The list to store the resulting compilation |
| 376 | /// inputs onto. |
| 377 | void BuildInputs(const ToolChain &TC, llvm::opt::DerivedArgList &Args, |
| 378 | InputList &Inputs) const; |
| 379 | |
| 380 | /// BuildActions - Construct the list of actions to perform for the |
| 381 | /// given arguments, which are only done for a single architecture. |
| 382 | /// |
| 383 | /// \param C - The compilation that is being built. |
| 384 | /// \param Args - The input arguments. |
| 385 | /// \param Actions - The list to store the resulting actions onto. |
| 386 | void BuildActions(Compilation &C, llvm::opt::DerivedArgList &Args, |
| 387 | const InputList &Inputs, ActionList &Actions) const; |
| 388 | |
| 389 | /// BuildUniversalActions - Construct the list of actions to perform |
| 390 | /// for the given arguments, which may require a universal build. |
| 391 | /// |
| 392 | /// \param C - The compilation that is being built. |
| 393 | /// \param TC - The default host tool chain. |
| 394 | void BuildUniversalActions(Compilation &C, const ToolChain &TC, |
| 395 | const InputList &BAInputs) const; |
| 396 | |
| 397 | /// BuildJobs - Bind actions to concrete tools and translate |
| 398 | /// arguments to form the list of jobs to run. |
| 399 | /// |
| 400 | /// \param C - The compilation that is being built. |
| 401 | void BuildJobs(Compilation &C) const; |
| 402 | |
| 403 | /// ExecuteCompilation - Execute the compilation according to the command line |
| 404 | /// arguments and return an appropriate exit code. |
| 405 | /// |
| 406 | /// This routine handles additional processing that must be done in addition |
| 407 | /// to just running the subprocesses, for example reporting errors, setting |
| 408 | /// up response files, removing temporary files, etc. |
| 409 | int ExecuteCompilation(Compilation &C, |
| 410 | SmallVectorImpl< std::pair<int, const Command *> > &FailingCommands); |
| 411 | |
| 412 | /// Contains the files in the compilation diagnostic report generated by |
| 413 | /// generateCompilationDiagnostics. |
| 414 | struct CompilationDiagnosticReport { |
| 415 | llvm::SmallVector<std::string, 4> TemporaryFiles; |
| 416 | }; |
| 417 | |
| 418 | /// generateCompilationDiagnostics - Generate diagnostics information |
| 419 | /// including preprocessed source file(s). |
| 420 | /// |
| 421 | void generateCompilationDiagnostics( |
| 422 | Compilation &C, const Command &FailingCommand, |
| 423 | StringRef AdditionalInformation = "", |
| 424 | CompilationDiagnosticReport *GeneratedReport = nullptr); |
| 425 | |
| 426 | /// @} |
| 427 | /// @name Helper Methods |
| 428 | /// @{ |
| 429 | |
| 430 | /// PrintActions - Print the list of actions. |
| 431 | void PrintActions(const Compilation &C) const; |
| 432 | |
| 433 | /// PrintHelp - Print the help text. |
| 434 | /// |
| 435 | /// \param ShowHidden - Show hidden options. |
| 436 | void PrintHelp(bool ShowHidden) const; |
| 437 | |
| 438 | /// PrintVersion - Print the driver version. |
| 439 | void PrintVersion(const Compilation &C, raw_ostream &OS) const; |
| 440 | |
| 441 | /// GetFilePath - Lookup \p Name in the list of file search paths. |
| 442 | /// |
| 443 | /// \param TC - The tool chain for additional information on |
| 444 | /// directories to search. |
| 445 | // |
| 446 | // FIXME: This should be in CompilationInfo. |
| 447 | std::string GetFilePath(StringRef Name, const ToolChain &TC) const; |
| 448 | |
| 449 | /// GetProgramPath - Lookup \p Name in the list of program search paths. |
| 450 | /// |
| 451 | /// \param TC - The provided tool chain for additional information on |
| 452 | /// directories to search. |
| 453 | // |
| 454 | // FIXME: This should be in CompilationInfo. |
| 455 | std::string GetProgramPath(StringRef Name, const ToolChain &TC) const; |
| 456 | |
| 457 | /// HandleAutocompletions - Handle --autocomplete by searching and printing |
| 458 | /// possible flags, descriptions, and its arguments. |
| 459 | void HandleAutocompletions(StringRef PassedFlags) const; |
| 460 | |
| 461 | /// HandleImmediateArgs - Handle any arguments which should be |
| 462 | /// treated before building actions or binding tools. |
| 463 | /// |
| 464 | /// \return Whether any compilation should be built for this |
| 465 | /// invocation. |
| 466 | bool HandleImmediateArgs(const Compilation &C); |
| 467 | |
| 468 | /// ConstructAction - Construct the appropriate action to do for |
| 469 | /// \p Phase on the \p Input, taking in to account arguments |
| 470 | /// like -fsyntax-only or --analyze. |
| 471 | Action *ConstructPhaseAction( |
| 472 | Compilation &C, const llvm::opt::ArgList &Args, phases::ID Phase, |
| 473 | Action *Input, |
| 474 | Action::OffloadKind TargetDeviceOffloadKind = Action::OFK_None) const; |
| 475 | |
| 476 | /// BuildJobsForAction - Construct the jobs to perform for the action \p A and |
| 477 | /// return an InputInfo for the result of running \p A. Will only construct |
| 478 | /// jobs for a given (Action, ToolChain, BoundArch, DeviceKind) tuple once. |
| 479 | InputInfo |
| 480 | BuildJobsForAction(Compilation &C, const Action *A, const ToolChain *TC, |
| 481 | StringRef BoundArch, bool AtTopLevel, bool MultipleArchs, |
| 482 | const char *LinkingOutput, |
| 483 | std::map<std::pair<const Action *, std::string>, InputInfo> |
| 484 | &CachedResults, |
| 485 | Action::OffloadKind TargetDeviceOffloadKind) const; |
| 486 | |
| 487 | /// Returns the default name for linked images (e.g., "a.out"). |
| 488 | const char *getDefaultImageName() const; |
| 489 | |
| 490 | /// GetNamedOutputPath - Return the name to use for the output of |
| 491 | /// the action \p JA. The result is appended to the compilation's |
| 492 | /// list of temporary or result files, as appropriate. |
| 493 | /// |
| 494 | /// \param C - The compilation. |
| 495 | /// \param JA - The action of interest. |
| 496 | /// \param BaseInput - The original input file that this action was |
| 497 | /// triggered by. |
| 498 | /// \param BoundArch - The bound architecture. |
| 499 | /// \param AtTopLevel - Whether this is a "top-level" action. |
| 500 | /// \param MultipleArchs - Whether multiple -arch options were supplied. |
| 501 | /// \param NormalizedTriple - The normalized triple of the relevant target. |
| 502 | const char *GetNamedOutputPath(Compilation &C, const JobAction &JA, |
| 503 | const char *BaseInput, StringRef BoundArch, |
| 504 | bool AtTopLevel, bool MultipleArchs, |
| 505 | StringRef NormalizedTriple) const; |
| 506 | |
| 507 | /// GetTemporaryPath - Return the pathname of a temporary file to use |
| 508 | /// as part of compilation; the file will have the given prefix and suffix. |
| 509 | /// |
| 510 | /// GCC goes to extra lengths here to be a bit more robust. |
| 511 | std::string GetTemporaryPath(StringRef Prefix, StringRef Suffix) const; |
| 512 | |
| 513 | /// GetTemporaryDirectory - Return the pathname of a temporary directory to |
| 514 | /// use as part of compilation; the directory will have the given prefix. |
| 515 | std::string GetTemporaryDirectory(StringRef Prefix) const; |
| 516 | |
| 517 | /// Return the pathname of the pch file in clang-cl mode. |
| 518 | std::string GetClPchPath(Compilation &C, StringRef BaseName) const; |
| 519 | |
| 520 | /// ShouldUseClangCompiler - Should the clang compiler be used to |
| 521 | /// handle this action. |
| 522 | bool ShouldUseClangCompiler(const JobAction &JA) const; |
| 523 | |
| 524 | /// Returns true if we are performing any kind of LTO. |
| 525 | bool isUsingLTO() const { return LTOMode != LTOK_None; } |
| 526 | |
| 527 | /// Get the specific kind of LTO being performed. |
| 528 | LTOKind getLTOMode() const { return LTOMode; } |
| 529 | |
| 530 | private: |
| 531 | |
| 532 | /// Tries to load options from configuration file. |
| 533 | /// |
| 534 | /// \returns true if error occurred. |
| 535 | bool loadConfigFile(); |
| 536 | |
| 537 | /// Read options from the specified file. |
| 538 | /// |
| 539 | /// \param [in] FileName File to read. |
| 540 | /// \returns true, if error occurred while reading. |
| 541 | bool readConfigFile(StringRef FileName); |
| 542 | |
| 543 | /// Set the driver mode (cl, gcc, etc) from an option string of the form |
| 544 | /// --driver-mode=<mode>. |
| 545 | void setDriverModeFromOption(StringRef Opt); |
| 546 | |
| 547 | /// Parse the \p Args list for LTO options and record the type of LTO |
| 548 | /// compilation based on which -f(no-)?lto(=.*)? option occurs last. |
| 549 | void setLTOMode(const llvm::opt::ArgList &Args); |
| 550 | |
| 551 | /// Retrieves a ToolChain for a particular \p Target triple. |
| 552 | /// |
| 553 | /// Will cache ToolChains for the life of the driver object, and create them |
| 554 | /// on-demand. |
| 555 | const ToolChain &getToolChain(const llvm::opt::ArgList &Args, |
| 556 | const llvm::Triple &Target) const; |
| 557 | |
| 558 | /// @} |
| 559 | |
| 560 | /// Get bitmasks for which option flags to include and exclude based on |
| 561 | /// the driver mode. |
| 562 | std::pair<unsigned, unsigned> getIncludeExcludeOptionFlagMasks(bool IsClCompatMode) const; |
| 563 | |
| 564 | /// Helper used in BuildJobsForAction. Doesn't use the cache when building |
| 565 | /// jobs specifically for the given action, but will use the cache when |
| 566 | /// building jobs for the Action's inputs. |
| 567 | InputInfo BuildJobsForActionNoCache( |
| 568 | Compilation &C, const Action *A, const ToolChain *TC, StringRef BoundArch, |
| 569 | bool AtTopLevel, bool MultipleArchs, const char *LinkingOutput, |
| 570 | std::map<std::pair<const Action *, std::string>, InputInfo> |
| 571 | &CachedResults, |
| 572 | Action::OffloadKind TargetDeviceOffloadKind) const; |
| 573 | |
| 574 | public: |
| 575 | /// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and |
| 576 | /// return the grouped values as integers. Numbers which are not |
| 577 | /// provided are set to 0. |
| 578 | /// |
| 579 | /// \return True if the entire string was parsed (9.2), or all |
| 580 | /// groups were parsed (10.3.5extrastuff). HadExtra is true if all |
| 581 | /// groups were parsed but extra characters remain at the end. |
| 582 | static bool GetReleaseVersion(StringRef Str, unsigned &Major, unsigned &Minor, |
| 583 | unsigned &Micro, bool &HadExtra); |
| 584 | |
| 585 | /// Parse digits from a string \p Str and fulfill \p Digits with |
| 586 | /// the parsed numbers. This method assumes that the max number of |
| 587 | /// digits to look for is equal to Digits.size(). |
| 588 | /// |
| 589 | /// \return True if the entire string was parsed and there are |
| 590 | /// no extra characters remaining at the end. |
| 591 | static bool GetReleaseVersion(StringRef Str, |
| 592 | MutableArrayRef<unsigned> Digits); |
| 593 | /// Compute the default -fmodule-cache-path. |
| 594 | static void getDefaultModuleCachePath(SmallVectorImpl<char> &Result); |
| 595 | }; |
| 596 | |
| 597 | /// \return True if the last defined optimization level is -Ofast. |
| 598 | /// And False otherwise. |
| 599 | bool isOptimizationLevelFast(const llvm::opt::ArgList &Args); |
| 600 | |
| 601 | } // end namespace driver |
| 602 | } // end namespace clang |
| 603 | |
| 604 | #endif |
| 605 |