ToolChain.h source code [clang_source_code/include/clang/Driver/ToolChain.h]

1	//===- ToolChain.h - Collections of tools for one platform ------- 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_TOOLCHAIN_H
10	#define LLVM_CLANG_DRIVER_TOOLCHAIN_H
11
12	#include "clang/Basic/DebugInfoOptions.h"
13	#include "clang/Basic/LLVM.h"
14	#include "clang/Basic/LangOptions.h"
15	#include "clang/Basic/Sanitizers.h"
16	#include "clang/Driver/Action.h"
17	#include "clang/Driver/Multilib.h"
18	#include "clang/Driver/Types.h"
19	#include "llvm/ADT/ArrayRef.h"
20	#include "llvm/ADT/SmallVector.h"
21	#include "llvm/ADT/StringRef.h"
22	#include "llvm/ADT/Triple.h"
23	#include "llvm/MC/MCTargetOptions.h"
24	#include "llvm/Option/Option.h"
25	#include "llvm/Support/VersionTuple.h"
26	#include "llvm/Target/TargetOptions.h"
27	#include <cassert>
28	#include <memory>
29	#include <string>
30	#include <utility>
31
32	namespace llvm {
33	namespace opt {
34
35	class Arg;
36	class ArgList;
37	class DerivedArgList;
38
39	} // namespace opt
40	namespace vfs {
41
42	class FileSystem;
43
44	} // namespace vfs
45	} // namespace llvm
46
47	namespace clang {
48
49	class ObjCRuntime;
50
51	namespace driver {
52
53	class Driver;
54	class InputInfo;
55	class SanitizerArgs;
56	class Tool;
57	class XRayArgs;
58
59	/// Helper structure used to pass information extracted from clang executable
60	/// name such as `i686-linux-android-g++`.
61	struct ParsedClangName {
62	/// Target part of the executable name, as `i686-linux-android`.
63	std::string TargetPrefix;
64
65	/// Driver mode part of the executable name, as `g++`.
66	std::string ModeSuffix;
67
68	/// Corresponding driver mode argument, as '--driver-mode=g++'
69	const char *DriverMode = nullptr;
70
71	/// True if TargetPrefix is recognized as a registered target name.
72	bool TargetIsValid = false;
73
74	ParsedClangName() = default;
75	ParsedClangName(std::string Suffix, const char *Mode)
76	: ModeSuffix(Suffix), DriverMode(Mode) {}
77	ParsedClangName(std::string Target, std::string Suffix, const char *Mode,
78	bool IsRegistered)
79	: TargetPrefix(Target), ModeSuffix(Suffix), DriverMode(Mode),
80	TargetIsValid(IsRegistered) {}
81
82	bool isEmpty() const {
83	return TargetPrefix.empty() && ModeSuffix.empty() && DriverMode == nullptr;
84	}
85	};
86
87	/// ToolChain - Access to tools for a single platform.
88	class ToolChain {
89	public:
90	using path_list = SmallVector<std::string, 16>;
91
92	enum CXXStdlibType {
93	CST_Libcxx,
94	CST_Libstdcxx
95	};
96
97	enum RuntimeLibType {
98	RLT_CompilerRT,
99	RLT_Libgcc
100	};
101
102	enum UnwindLibType {
103	UNW_None,
104	UNW_CompilerRT,
105	UNW_Libgcc
106	};
107
108	enum RTTIMode {
109	RM_Enabled,
110	RM_Disabled,
111	};
112
113	enum FileType { FT_Object, FT_Static, FT_Shared };
114
115	private:
116	friend class RegisterEffectiveTriple;
117
118	const Driver &D;
119	llvm::Triple Triple;
120	const llvm::opt::ArgList &Args;
121
122	// We need to initialize CachedRTTIArg before CachedRTTIMode
123	const llvm::opt::Arg *const CachedRTTIArg;
124
125	const RTTIMode CachedRTTIMode;
126
127	/// The list of toolchain specific path prefixes to search for libraries.
128	path_list LibraryPaths;
129
130	/// The list of toolchain specific path prefixes to search for files.
131	path_list FilePaths;
132
133	/// The list of toolchain specific path prefixes to search for programs.
134	path_list ProgramPaths;
135
136	mutable std::unique_ptr<Tool> Clang;
137	mutable std::unique_ptr<Tool> Assemble;
138	mutable std::unique_ptr<Tool> Link;
139	mutable std::unique_ptr<Tool> OffloadBundler;
140
141	Tool *getClang() const;
142	Tool *getAssemble() const;
143	Tool *getLink() const;
144	Tool *getClangAs() const;
145	Tool *getOffloadBundler() const;
146
147	mutable std::unique_ptr<SanitizerArgs> SanitizerArguments;
148	mutable std::unique_ptr<XRayArgs> XRayArguments;
149
150	/// The effective clang triple for the current Job.
151	mutable llvm::Triple EffectiveTriple;
152
153	/// Set the toolchain's effective clang triple.
154	void setEffectiveTriple(llvm::Triple ET) const {
155	EffectiveTriple = std::move(ET);
156	}
157
158	protected:
159	MultilibSet Multilibs;
160	Multilib SelectedMultilib;
161
162	ToolChain(const Driver &D, const llvm::Triple &T,
163	const llvm::opt::ArgList &Args);
164
165	void setTripleEnvironment(llvm::Triple::EnvironmentType Env);
166
167	virtual Tool *buildAssembler() const;
168	virtual Tool *buildLinker() const;
169	virtual Tool *getTool(Action::ActionClass AC) const;
170
171	/// \name Utilities for implementing subclasses.
172	///@{
173	static void addSystemInclude(const llvm::opt::ArgList &DriverArgs,
174	llvm::opt::ArgStringList &CC1Args,
175	const Twine &Path);
176	static void addExternCSystemInclude(const llvm::opt::ArgList &DriverArgs,
177	llvm::opt::ArgStringList &CC1Args,
178	const Twine &Path);
179	static void
180	addExternCSystemIncludeIfExists(const llvm::opt::ArgList &DriverArgs,
181	llvm::opt::ArgStringList &CC1Args,
182	const Twine &Path);
183	static void addSystemIncludes(const llvm::opt::ArgList &DriverArgs,
184	llvm::opt::ArgStringList &CC1Args,
185	ArrayRef<StringRef> Paths);
186	///@}
187
188	public:
189	virtual ~ToolChain();
190
191	// Accessors
192
193	const Driver &getDriver() const { return D; }
194	llvm::vfs::FileSystem &getVFS() const;
195	const llvm::Triple &getTriple() const { return Triple; }
196
197	/// Get the toolchain's aux triple, if it has one.
198	///
199	/// Exactly what the aux triple represents depends on the toolchain, but for
200	/// example when compiling CUDA code for the GPU, the triple might be NVPTX,
201	/// while the aux triple is the host (CPU) toolchain, e.g. x86-linux-gnu.
202	virtual const llvm::Triple *getAuxTriple() const { return nullptr; }
203
204	/// Some toolchains need to modify the file name, for example to replace the
205	/// extension for object files with .cubin for OpenMP offloading to Nvidia
206	/// GPUs.
207	virtual std::string getInputFilename(const InputInfo &Input) const;
208
209	llvm::Triple::ArchType getArch() const { return Triple.getArch(); }
210	StringRef getArchName() const { return Triple.getArchName(); }
211	StringRef getPlatform() const { return Triple.getVendorName(); }
212	StringRef getOS() const { return Triple.getOSName(); }
213
214	/// Provide the default architecture name (as expected by -arch) for
215	/// this toolchain.
216	StringRef getDefaultUniversalArchName() const;
217
218	std::string getTripleString() const {
219	return Triple.getTriple();
220	}
221
222	/// Get the toolchain's effective clang triple.
223	const llvm::Triple &getEffectiveTriple() const {
224	(0) . __assert_fail ("!EffectiveTriple.getTriple().empty() && \"No effective triple\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Driver/ToolChain.h", 224, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(!EffectiveTriple.getTriple().empty() && "No effective triple");
225	return EffectiveTriple;
226	}
227
228	path_list &getLibraryPaths() { return LibraryPaths; }
229	const path_list &getLibraryPaths() const { return LibraryPaths; }
230
231	path_list &getFilePaths() { return FilePaths; }
232	const path_list &getFilePaths() const { return FilePaths; }
233
234	path_list &getProgramPaths() { return ProgramPaths; }
235	const path_list &getProgramPaths() const { return ProgramPaths; }
236
237	const MultilibSet &getMultilibs() const { return Multilibs; }
238
239	const Multilib &getMultilib() const { return SelectedMultilib; }
240
241	const SanitizerArgs& getSanitizerArgs() const;
242
243	const XRayArgs& getXRayArgs() const;
244
245	// Returns the Arg * that explicitly turned on/off rtti, or nullptr.
246	const llvm::opt::Arg *getRTTIArg() const { return CachedRTTIArg; }
247
248	// Returns the RTTIMode for the toolchain with the current arguments.
249	RTTIMode getRTTIMode() const { return CachedRTTIMode; }
250
251	/// Return any implicit target and/or mode flag for an invocation of
252	/// the compiler driver as `ProgName`.
253	///
254	/// For example, when called with i686-linux-android-g++, the first element
255	/// of the return value will be set to `"i686-linux-android"` and the second
256	/// will be set to "--driver-mode=g++"`.
257	/// It is OK if the target name is not registered. In this case the return
258	/// value contains false in the field TargetIsValid.
259	///
260	/// \pre `llvm::InitializeAllTargets()` has been called.
261	/// \param ProgName The name the Clang driver was invoked with (from,
262	/// e.g., argv[0]).
263	/// \return A structure of type ParsedClangName that contains the executable
264	/// name parts.
265	static ParsedClangName getTargetAndModeFromProgramName(StringRef ProgName);
266
267	// Tool access.
268
269	/// TranslateArgs - Create a new derived argument list for any argument
270	/// translations this ToolChain may wish to perform, or 0 if no tool chain
271	/// specific translations are needed. If \p DeviceOffloadKind is specified
272	/// the translation specific for that offload kind is performed.
273	///
274	/// \param BoundArch - The bound architecture name, or 0.
275	/// \param DeviceOffloadKind - The device offload kind used for the
276	/// translation.
277	virtual llvm::opt::DerivedArgList *
278	TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
279	Action::OffloadKind DeviceOffloadKind) const {
280	return nullptr;
281	}
282
283	/// TranslateOpenMPTargetArgs - Create a new derived argument list for
284	/// that contains the OpenMP target specific flags passed via
285	/// -Xopenmp-target -opt=val OR -Xopenmp-target=<triple> -opt=val
286	virtual llvm::opt::DerivedArgList *TranslateOpenMPTargetArgs(
287	const llvm::opt::DerivedArgList &Args, bool SameTripleAsHost,
288	SmallVectorImpl<llvm::opt::Arg *> &AllocatedArgs) const;
289
290	/// Choose a tool to use to handle the action \p JA.
291	///
292	/// This can be overridden when a particular ToolChain needs to use
293	/// a compiler other than Clang.
294	virtual Tool *SelectTool(const JobAction &JA) const;
295
296	// Helper methods
297
298	std::string GetFilePath(const char *Name) const;
299	std::string GetProgramPath(const char *Name) const;
300
301	/// Returns the linker path, respecting the -fuse-ld= argument to determine
302	/// the linker suffix or name.
303	std::string GetLinkerPath() const;
304
305	/// Dispatch to the specific toolchain for verbose printing.
306	///
307	/// This is used when handling the verbose option to print detailed,
308	/// toolchain-specific information useful for understanding the behavior of
309	/// the driver on a specific platform.
310	virtual void printVerboseInfo(raw_ostream &OS) const {}
311
312	// Platform defaults information
313
314	/// Returns true if the toolchain is targeting a non-native
315	/// architecture.
316	virtual bool isCrossCompiling() const;
317
318	/// HasNativeLTOLinker - Check whether the linker and related tools have
319	/// native LLVM support.
320	virtual bool HasNativeLLVMSupport() const;
321
322	/// LookupTypeForExtension - Return the default language type to use for the
323	/// given extension.
324	virtual types::ID LookupTypeForExtension(StringRef Ext) const;
325
326	/// IsBlocksDefault - Does this tool chain enable -fblocks by default.
327	virtual bool IsBlocksDefault() const { return false; }
328
329	/// IsIntegratedAssemblerDefault - Does this tool chain enable -integrated-as
330	/// by default.
331	virtual bool IsIntegratedAssemblerDefault() const { return false; }
332
333	/// Check if the toolchain should use the integrated assembler.
334	virtual bool useIntegratedAs() const;
335
336	/// IsMathErrnoDefault - Does this tool chain use -fmath-errno by default.
337	virtual bool IsMathErrnoDefault() const { return true; }
338
339	/// IsEncodeExtendedBlockSignatureDefault - Does this tool chain enable
340	/// -fencode-extended-block-signature by default.
341	virtual bool IsEncodeExtendedBlockSignatureDefault() const { return false; }
342
343	/// IsObjCNonFragileABIDefault - Does this tool chain set
344	/// -fobjc-nonfragile-abi by default.
345	virtual bool IsObjCNonFragileABIDefault() const { return false; }
346
347	/// UseObjCMixedDispatchDefault - When using non-legacy dispatch, should the
348	/// mixed dispatch method be used?
349	virtual bool UseObjCMixedDispatch() const { return false; }
350
351	/// Check whether to enable x86 relax relocations by default.
352	virtual bool useRelaxRelocations() const;
353
354	/// GetDefaultStackProtectorLevel - Get the default stack protector level for
355	/// this tool chain (0=off, 1=on, 2=strong, 3=all).
356	virtual unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const {
357	return 0;
358	}
359
360	/// Get the default trivial automatic variable initialization.
361	virtual LangOptions::TrivialAutoVarInitKind
362	GetDefaultTrivialAutoVarInit() const {
363	return LangOptions::TrivialAutoVarInitKind::Uninitialized;
364	}
365
366	/// GetDefaultLinker - Get the default linker to use.
367	virtual const char *getDefaultLinker() const { return "ld"; }
368
369	/// GetDefaultRuntimeLibType - Get the default runtime library variant to use.
370	virtual RuntimeLibType GetDefaultRuntimeLibType() const {
371	return ToolChain::RLT_Libgcc;
372	}
373
374	virtual CXXStdlibType GetDefaultCXXStdlibType() const {
375	return ToolChain::CST_Libstdcxx;
376	}
377
378	virtual UnwindLibType GetDefaultUnwindLibType() const {
379	return ToolChain::UNW_None;
380	}
381
382	virtual std::string getCompilerRTPath() const;
383
384	virtual std::string getCompilerRT(const llvm::opt::ArgList &Args,
385	StringRef Component,
386	FileType Type = ToolChain::FT_Static) const;
387
388	const char *
389	getCompilerRTArgString(const llvm::opt::ArgList &Args, StringRef Component,
390	FileType Type = ToolChain::FT_Static) const;
391
392	// Returns <ResourceDir>/lib/<OSName>/<arch>. This is used by runtimes (such
393	// as OpenMP) to find arch-specific libraries.
394	std::string getArchSpecificLibPath() const;
395
396	// Returns <OSname> part of above.
397	StringRef getOSLibName() const;
398
399	/// needsProfileRT - returns true if instrumentation profile is on.
400	static bool needsProfileRT(const llvm::opt::ArgList &Args);
401
402	/// Returns true if gcov instrumentation (-fprofile-arcs or --coverage) is on.
403	static bool needsGCovInstrumentation(const llvm::opt::ArgList &Args);
404
405	/// IsUnwindTablesDefault - Does this tool chain use -funwind-tables
406	/// by default.
407	virtual bool IsUnwindTablesDefault(const llvm::opt::ArgList &Args) const;
408
409	/// Test whether this toolchain defaults to PIC.
410	virtual bool isPICDefault() const = 0;
411
412	/// Test whether this toolchain defaults to PIE.
413	virtual bool isPIEDefault() const = 0;
414
415	/// Test whether this toolchaind defaults to non-executable stacks.
416	virtual bool isNoExecStackDefault() const;
417
418	/// Tests whether this toolchain forces its default for PIC, PIE or
419	/// non-PIC. If this returns true, any PIC related flags should be ignored
420	/// and instead the results of \c isPICDefault() and \c isPIEDefault() are
421	/// used exclusively.
422	virtual bool isPICDefaultForced() const = 0;
423
424	/// SupportsProfiling - Does this tool chain support -pg.
425	virtual bool SupportsProfiling() const { return true; }
426
427	/// Complain if this tool chain doesn't support Objective-C ARC.
428	virtual void CheckObjCARC() const {}
429
430	/// Get the default debug info format. Typically, this is DWARF.
431	virtual codegenoptions::DebugInfoFormat getDefaultDebugFormat() const {
432	return codegenoptions::DIF_DWARF;
433	}
434
435	/// UseDwarfDebugFlags - Embed the compile options to clang into the Dwarf
436	/// compile unit information.
437	virtual bool UseDwarfDebugFlags() const { return false; }
438
439	// Return the DWARF version to emit, in the absence of arguments
440	// to the contrary.
441	virtual unsigned GetDefaultDwarfVersion() const { return 4; }
442
443	// True if the driver should assume "-fstandalone-debug"
444	// in the absence of an option specifying otherwise,
445	// provided that debugging was requested in the first place.
446	// i.e. a value of 'true' does not imply that debugging is wanted.
447	virtual bool GetDefaultStandaloneDebug() const { return false; }
448
449	// Return the default debugger "tuning."
450	virtual llvm::DebuggerKind getDefaultDebuggerTuning() const {
451	return llvm::DebuggerKind::GDB;
452	}
453
454	/// Does this toolchain supports given debug info option or not.
455	virtual bool supportsDebugInfoOption(const llvm::opt::Arg *) const {
456	return true;
457	}
458
459	/// Adjust debug information kind considering all passed options.
460	virtual void adjustDebugInfoKind(codegenoptions::DebugInfoKind &DebugInfoKind,
461	const llvm::opt::ArgList &Args) const {}
462
463	/// GetExceptionModel - Return the tool chain exception model.
464	virtual llvm::ExceptionHandling
465	GetExceptionModel(const llvm::opt::ArgList &Args) const;
466
467	/// SupportsEmbeddedBitcode - Does this tool chain support embedded bitcode.
468	virtual bool SupportsEmbeddedBitcode() const { return false; }
469
470	/// getThreadModel() - Which thread model does this target use?
471	virtual std::string getThreadModel() const { return "posix"; }
472
473	/// isThreadModelSupported() - Does this target support a thread model?
474	virtual bool isThreadModelSupported(const StringRef Model) const;
475
476	/// ComputeLLVMTriple - Return the LLVM target triple to use, after taking
477	/// command line arguments into account.
478	virtual std::string
479	ComputeLLVMTriple(const llvm::opt::ArgList &Args,
480	types::ID InputType = types::TY_INVALID) const;
481
482	/// ComputeEffectiveClangTriple - Return the Clang triple to use for this
483	/// target, which may take into account the command line arguments. For
484	/// example, on Darwin the -mmacosx-version-min= command line argument (which
485	/// sets the deployment target) determines the version in the triple passed to
486	/// Clang.
487	virtual std::string ComputeEffectiveClangTriple(
488	const llvm::opt::ArgList &Args,
489	types::ID InputType = types::TY_INVALID) const;
490
491	/// getDefaultObjCRuntime - Return the default Objective-C runtime
492	/// for this platform.
493	///
494	/// FIXME: this really belongs on some sort of DeploymentTarget abstraction
495	virtual ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const;
496
497	/// hasBlocksRuntime - Given that the user is compiling with
498	/// -fblocks, does this tool chain guarantee the existence of a
499	/// blocks runtime?
500	///
501	/// FIXME: this really belongs on some sort of DeploymentTarget abstraction
502	virtual bool hasBlocksRuntime() const { return true; }
503
504	/// Add the clang cc1 arguments for system include paths.
505	///
506	/// This routine is responsible for adding the necessary cc1 arguments to
507	/// include headers from standard system header directories.
508	virtual void
509	AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
510	llvm::opt::ArgStringList &CC1Args) const;
511
512	/// Add options that need to be passed to cc1 for this target.
513	virtual void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
514	llvm::opt::ArgStringList &CC1Args,
515	Action::OffloadKind DeviceOffloadKind) const;
516
517	/// Add warning options that need to be passed to cc1 for this target.
518	virtual void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const;
519
520	// GetRuntimeLibType - Determine the runtime library type to use with the
521	// given compilation arguments.
522	virtual RuntimeLibType
523	GetRuntimeLibType(const llvm::opt::ArgList &Args) const;
524
525	// GetCXXStdlibType - Determine the C++ standard library type to use with the
526	// given compilation arguments.
527	virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const;
528
529	// GetUnwindLibType - Determine the unwind library type to use with the
530	// given compilation arguments.
531	virtual UnwindLibType GetUnwindLibType(const llvm::opt::ArgList &Args) const;
532
533	/// AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set
534	/// the include paths to use for the given C++ standard library type.
535	virtual void
536	AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
537	llvm::opt::ArgStringList &CC1Args) const;
538
539	/// Returns if the C++ standard library should be linked in.
540	/// Note that e.g. -lm should still be linked even if this returns false.
541	bool ShouldLinkCXXStdlib(const llvm::opt::ArgList &Args) const;
542
543	/// AddCXXStdlibLibArgs - Add the system specific linker arguments to use
544	/// for the given C++ standard library type.
545	virtual void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
546	llvm::opt::ArgStringList &CmdArgs) const;
547
548	/// AddFilePathLibArgs - Add each thing in getFilePaths() as a "-L" option.
549	void AddFilePathLibArgs(const llvm::opt::ArgList &Args,
550	llvm::opt::ArgStringList &CmdArgs) const;
551
552	/// AddCCKextLibArgs - Add the system specific linker arguments to use
553	/// for kernel extensions (Darwin-specific).
554	virtual void AddCCKextLibArgs(const llvm::opt::ArgList &Args,
555	llvm::opt::ArgStringList &CmdArgs) const;
556
557	/// AddFastMathRuntimeIfAvailable - If a runtime library exists that sets
558	/// global flags for unsafe floating point math, add it and return true.
559	///
560	/// This checks for presence of the -Ofast, -ffast-math or -funsafe-math flags.
561	virtual bool AddFastMathRuntimeIfAvailable(
562	const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const;
563
564	/// addProfileRTLibs - When -fprofile-instr-profile is specified, try to pass
565	/// a suitable profile runtime library to the linker.
566	virtual void addProfileRTLibs(const llvm::opt::ArgList &Args,
567	llvm::opt::ArgStringList &CmdArgs) const;
568
569	/// Add arguments to use system-specific CUDA includes.
570	virtual void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
571	llvm::opt::ArgStringList &CC1Args) const;
572
573	/// Add arguments to use MCU GCC toolchain includes.
574	virtual void AddIAMCUIncludeArgs(const llvm::opt::ArgList &DriverArgs,
575	llvm::opt::ArgStringList &CC1Args) const;
576
577	/// On Windows, returns the MSVC compatibility version.
578	virtual VersionTuple computeMSVCVersion(const Driver *D,
579	const llvm::opt::ArgList &Args) const;
580
581	/// Return sanitizers which are available in this toolchain.
582	virtual SanitizerMask getSupportedSanitizers() const;
583
584	/// Return sanitizers which are enabled by default.
585	virtual SanitizerMask getDefaultSanitizers() const {
586	return SanitizerMask();
587	}
588	};
589
590	/// Set a ToolChain's effective triple. Reset it when the registration object
591	/// is destroyed.
592	class RegisterEffectiveTriple {
593	const ToolChain &TC;
594
595	public:
596	RegisterEffectiveTriple(const ToolChain &TC, llvm::Triple T) : TC(TC) {
597	TC.setEffectiveTriple(std::move(T));
598	}
599
600	~RegisterEffectiveTriple() { TC.setEffectiveTriple(llvm::Triple()); }
601	};
602
603	} // namespace driver
604
605	} // namespace clang
606
607	#endif // LLVM_CLANG_DRIVER_TOOLCHAIN_H
608