ToolChains.h revision c9b8daa1fb95f10d4d5c151697bbeefa17c93f70 
1//===--- ToolChains.h - ToolChain Implementations ---------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef CLANG_LIB_DRIVER_TOOLCHAINS_H_
11#define CLANG_LIB_DRIVER_TOOLCHAINS_H_
12
13#include "clang/Driver/Action.h"
14#include "clang/Driver/ToolChain.h"
15
16#include "llvm/ADT/DenseMap.h"
17#include "llvm/Support/Compiler.h"
18
19#include "Tools.h"
20
21namespace clang {
22namespace driver {
23namespace toolchains {
24
25/// Generic_GCC - A tool chain using the 'gcc' command to perform
26/// all subcommands; this relies on gcc translating the majority of
27/// command line options.
28class LLVM_LIBRARY_VISIBILITY Generic_GCC : public ToolChain {
29protected:
30  mutable llvm::DenseMap<unsigned, Tool*> Tools;
31
32public:
33  Generic_GCC(const HostInfo &Host, const llvm::Triple& Triple);
34  ~Generic_GCC();
35
36  virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
37                           const ActionList &Inputs) const;
38
39  virtual bool IsUnwindTablesDefault() const;
40  virtual const char *GetDefaultRelocationModel() const;
41  virtual const char *GetForcedPicModel() const;
42};
43
44/// Darwin - The base Darwin tool chain.
45class LLVM_LIBRARY_VISIBILITY Darwin : public ToolChain {
46public:
47  /// The host version.
48  unsigned DarwinVersion[3];
49
50private:
51  mutable llvm::DenseMap<unsigned, Tool*> Tools;
52
53  /// Whether the information on the target has been initialized.
54  //
55  // FIXME: This should be eliminated. What we want to do is make this part of
56  // the "default target for arguments" selection process, once we get out of
57  // the argument translation business.
58  mutable bool TargetInitialized;
59
60  // FIXME: Remove this once there is a proper way to detect an ARC runtime
61  // for the simulator.
62 public:
63  mutable enum {
64    ARCSimulator_None,
65    ARCSimulator_HasARCRuntime,
66    ARCSimulator_NoARCRuntime
67  } ARCRuntimeForSimulator;
68
69  mutable enum {
70    LibCXXSimulator_None,
71    LibCXXSimulator_NotAvailable,
72    LibCXXSimulator_Available
73  } LibCXXForSimulator;
74
75private:
76  /// Whether we are targeting iPhoneOS target.
77  mutable bool TargetIsIPhoneOS;
78
79  /// Whether we are targeting the iPhoneOS simulator target.
80  mutable bool TargetIsIPhoneOSSimulator;
81
82  /// The OS version we are targeting.
83  mutable unsigned TargetVersion[3];
84
85  /// The default macosx-version-min of this tool chain; empty until
86  /// initialized.
87  std::string MacosxVersionMin;
88
89  bool hasARCRuntime() const;
90
91private:
92  void AddDeploymentTarget(DerivedArgList &Args) const;
93
94public:
95  Darwin(const HostInfo &Host, const llvm::Triple& Triple);
96  ~Darwin();
97
98  std::string ComputeEffectiveClangTriple(const ArgList &Args,
99                                          types::ID InputType) const;
100
101  /// @name Darwin Specific Toolchain API
102  /// {
103
104  // FIXME: Eliminate these ...Target functions and derive separate tool chains
105  // for these targets and put version in constructor.
106  void setTarget(bool IsIPhoneOS, unsigned Major, unsigned Minor,
107                 unsigned Micro, bool IsIOSSim) const {
108    assert((!IsIOSSim || IsIPhoneOS) && "Unexpected deployment target!");
109
110    // FIXME: For now, allow reinitialization as long as values don't
111    // change. This will go away when we move away from argument translation.
112    if (TargetInitialized && TargetIsIPhoneOS == IsIPhoneOS &&
113        TargetIsIPhoneOSSimulator == IsIOSSim &&
114        TargetVersion[0] == Major && TargetVersion[1] == Minor &&
115        TargetVersion[2] == Micro)
116      return;
117
118    assert(!TargetInitialized && "Target already initialized!");
119    TargetInitialized = true;
120    TargetIsIPhoneOS = IsIPhoneOS;
121    TargetIsIPhoneOSSimulator = IsIOSSim;
122    TargetVersion[0] = Major;
123    TargetVersion[1] = Minor;
124    TargetVersion[2] = Micro;
125  }
126
127  bool isTargetIPhoneOS() const {
128    assert(TargetInitialized && "Target not initialized!");
129    return TargetIsIPhoneOS;
130  }
131
132  bool isTargetIOSSimulator() const {
133    assert(TargetInitialized && "Target not initialized!");
134    return TargetIsIPhoneOSSimulator;
135  }
136
137  bool isTargetInitialized() const { return TargetInitialized; }
138
139  void getTargetVersion(unsigned (&Res)[3]) const {
140    assert(TargetInitialized && "Target not initialized!");
141    Res[0] = TargetVersion[0];
142    Res[1] = TargetVersion[1];
143    Res[2] = TargetVersion[2];
144  }
145
146  /// getDarwinArchName - Get the "Darwin" arch name for a particular compiler
147  /// invocation. For example, Darwin treats different ARM variations as
148  /// distinct architectures.
149  StringRef getDarwinArchName(const ArgList &Args) const;
150
151  static bool isVersionLT(unsigned (&A)[3], unsigned (&B)[3]) {
152    for (unsigned i=0; i < 3; ++i) {
153      if (A[i] > B[i]) return false;
154      if (A[i] < B[i]) return true;
155    }
156    return false;
157  }
158
159  bool isIPhoneOSVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const {
160    assert(isTargetIPhoneOS() && "Unexpected call for OS X target!");
161    unsigned B[3] = { V0, V1, V2 };
162    return isVersionLT(TargetVersion, B);
163  }
164
165  bool isMacosxVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const {
166    assert(!isTargetIPhoneOS() && "Unexpected call for iPhoneOS target!");
167    unsigned B[3] = { V0, V1, V2 };
168    return isVersionLT(TargetVersion, B);
169  }
170
171  /// AddLinkSearchPathArgs - Add the linker search paths to \arg CmdArgs.
172  ///
173  /// \param Args - The input argument list.
174  /// \param CmdArgs [out] - The command argument list to append the paths
175  /// (prefixed by -L) to.
176  virtual void AddLinkSearchPathArgs(const ArgList &Args,
177                                     ArgStringList &CmdArgs) const = 0;
178
179  /// AddLinkARCArgs - Add the linker arguments to link the ARC runtime library.
180  virtual void AddLinkARCArgs(const ArgList &Args,
181                              ArgStringList &CmdArgs) const = 0;
182
183  /// AddLinkRuntimeLibArgs - Add the linker arguments to link the compiler
184  /// runtime library.
185  virtual void AddLinkRuntimeLibArgs(const ArgList &Args,
186                                     ArgStringList &CmdArgs) const = 0;
187
188  /// }
189  /// @name ToolChain Implementation
190  /// {
191
192  virtual types::ID LookupTypeForExtension(const char *Ext) const;
193
194  virtual bool HasNativeLLVMSupport() const;
195
196  virtual void configureObjCRuntime(ObjCRuntime &runtime) const;
197  virtual bool hasBlocksRuntime() const;
198
199  virtual DerivedArgList *TranslateArgs(const DerivedArgList &Args,
200                                        const char *BoundArch) const;
201
202  virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
203                           const ActionList &Inputs) const;
204
205  virtual bool IsBlocksDefault() const {
206    // Always allow blocks on Darwin; users interested in versioning are
207    // expected to use /usr/include/Blocks.h.
208    return true;
209  }
210  virtual bool IsIntegratedAssemblerDefault() const {
211#ifdef DISABLE_DEFAULT_INTEGRATED_ASSEMBLER
212    return false;
213#else
214    // Default integrated assembler to on for x86.
215    return (getTriple().getArch() == llvm::Triple::x86 ||
216            getTriple().getArch() == llvm::Triple::x86_64);
217#endif
218  }
219  virtual bool IsStrictAliasingDefault() const {
220#ifdef DISABLE_DEFAULT_STRICT_ALIASING
221    return false;
222#else
223    return ToolChain::IsStrictAliasingDefault();
224#endif
225  }
226
227  virtual bool IsObjCDefaultSynthPropertiesDefault() const {
228    return false;
229  }
230
231  virtual bool IsObjCNonFragileABIDefault() const {
232    // Non-fragile ABI is default for everything but i386.
233    return getTriple().getArch() != llvm::Triple::x86;
234  }
235  virtual bool IsObjCLegacyDispatchDefault() const {
236    // This is only used with the non-fragile ABI.
237
238    // Legacy dispatch is used everywhere except on x86_64.
239    return getTriple().getArch() != llvm::Triple::x86_64;
240  }
241  virtual bool UseObjCMixedDispatch() const {
242    // This is only used with the non-fragile ABI and non-legacy dispatch.
243
244    // Mixed dispatch is used everywhere except OS X before 10.6.
245    return !(!isTargetIPhoneOS() && isMacosxVersionLT(10, 6));
246  }
247  virtual bool IsUnwindTablesDefault() const;
248  virtual unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const {
249    // Stack protectors default to on for user code on 10.5,
250    // and for everything in 10.6 and beyond
251    return !isTargetIPhoneOS() &&
252      (!isMacosxVersionLT(10, 6) ||
253         (!isMacosxVersionLT(10, 5) && !KernelOrKext));
254  }
255  virtual const char *GetDefaultRelocationModel() const;
256  virtual const char *GetForcedPicModel() const;
257
258  virtual bool SupportsProfiling() const;
259
260  virtual bool SupportsObjCGC() const;
261
262  virtual bool UseDwarfDebugFlags() const;
263
264  virtual bool UseSjLjExceptions() const;
265
266  /// }
267};
268
269/// DarwinClang - The Darwin toolchain used by Clang.
270class LLVM_LIBRARY_VISIBILITY DarwinClang : public Darwin {
271private:
272  void AddGCCLibexecPath(unsigned darwinVersion);
273
274public:
275  DarwinClang(const HostInfo &Host, const llvm::Triple& Triple);
276
277  /// @name Darwin ToolChain Implementation
278  /// {
279
280  virtual void AddLinkSearchPathArgs(const ArgList &Args,
281                                    ArgStringList &CmdArgs) const;
282
283  virtual void AddLinkRuntimeLibArgs(const ArgList &Args,
284                                     ArgStringList &CmdArgs) const;
285  void AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs,
286                         const char *DarwinStaticLib) const;
287
288  virtual void AddCXXStdlibLibArgs(const ArgList &Args,
289                                   ArgStringList &CmdArgs) const;
290
291  virtual void AddCCKextLibArgs(const ArgList &Args,
292                                ArgStringList &CmdArgs) const;
293
294  virtual void AddLinkARCArgs(const ArgList &Args,
295                              ArgStringList &CmdArgs) const;
296  /// }
297};
298
299/// Darwin_Generic_GCC - Generic Darwin tool chain using gcc.
300class LLVM_LIBRARY_VISIBILITY Darwin_Generic_GCC : public Generic_GCC {
301public:
302  Darwin_Generic_GCC(const HostInfo &Host, const llvm::Triple& Triple)
303    : Generic_GCC(Host, Triple) {}
304
305  std::string ComputeEffectiveClangTriple(const ArgList &Args,
306                                          types::ID InputType) const;
307
308  virtual const char *GetDefaultRelocationModel() const { return "pic"; }
309};
310
311class LLVM_LIBRARY_VISIBILITY Generic_ELF : public Generic_GCC {
312 public:
313  Generic_ELF(const HostInfo &Host, const llvm::Triple& Triple)
314    : Generic_GCC(Host, Triple) {}
315
316  virtual bool IsIntegratedAssemblerDefault() const {
317    // Default integrated assembler to on for x86.
318    return (getTriple().getArch() == llvm::Triple::x86 ||
319            getTriple().getArch() == llvm::Triple::x86_64);
320  }
321};
322
323class LLVM_LIBRARY_VISIBILITY AuroraUX : public Generic_GCC {
324public:
325  AuroraUX(const HostInfo &Host, const llvm::Triple& Triple);
326
327  virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
328                           const ActionList &Inputs) const;
329};
330
331class LLVM_LIBRARY_VISIBILITY OpenBSD : public Generic_ELF {
332public:
333  OpenBSD(const HostInfo &Host, const llvm::Triple& Triple);
334
335  virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
336                           const ActionList &Inputs) const;
337};
338
339class LLVM_LIBRARY_VISIBILITY FreeBSD : public Generic_ELF {
340public:
341  FreeBSD(const HostInfo &Host, const llvm::Triple& Triple);
342
343  virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
344                           const ActionList &Inputs) const;
345};
346
347class LLVM_LIBRARY_VISIBILITY NetBSD : public Generic_ELF {
348  const llvm::Triple ToolTriple;
349
350public:
351  NetBSD(const HostInfo &Host, const llvm::Triple& Triple,
352         const llvm::Triple& ToolTriple);
353
354  virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
355                           const ActionList &Inputs) const;
356};
357
358class LLVM_LIBRARY_VISIBILITY Minix : public Generic_GCC {
359public:
360  Minix(const HostInfo &Host, const llvm::Triple& Triple);
361
362  virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
363                           const ActionList &Inputs) const;
364};
365
366class LLVM_LIBRARY_VISIBILITY DragonFly : public Generic_ELF {
367public:
368  DragonFly(const HostInfo &Host, const llvm::Triple& Triple);
369
370  virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
371                           const ActionList &Inputs) const;
372};
373
374class LLVM_LIBRARY_VISIBILITY Linux : public Generic_ELF {
375public:
376  Linux(const HostInfo &Host, const llvm::Triple& Triple);
377
378  virtual bool HasNativeLLVMSupport() const;
379
380  virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
381                           const ActionList &Inputs) const;
382
383  virtual void AddClangSystemIncludeArgs(const ArgList &DriverArgs,
384                                         ArgStringList &CC1Args) const;
385  virtual void AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
386                                            ArgStringList &CC1Args) const;
387
388  std::string Linker;
389  std::vector<std::string> ExtraOpts;
390};
391
392
393/// TCEToolChain - A tool chain using the llvm bitcode tools to perform
394/// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
395class LLVM_LIBRARY_VISIBILITY TCEToolChain : public ToolChain {
396public:
397  TCEToolChain(const HostInfo &Host, const llvm::Triple& Triple);
398  ~TCEToolChain();
399
400  virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
401                           const ActionList &Inputs) const;
402  bool IsMathErrnoDefault() const;
403  bool IsUnwindTablesDefault() const;
404  const char* GetDefaultRelocationModel() const;
405  const char* GetForcedPicModel() const;
406
407private:
408  mutable llvm::DenseMap<unsigned, Tool*> Tools;
409
410};
411
412class LLVM_LIBRARY_VISIBILITY Windows : public ToolChain {
413  mutable llvm::DenseMap<unsigned, Tool*> Tools;
414
415public:
416  Windows(const HostInfo &Host, const llvm::Triple& Triple);
417
418  virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
419                           const ActionList &Inputs) const;
420
421  virtual bool IsIntegratedAssemblerDefault() const;
422  virtual bool IsUnwindTablesDefault() const;
423  virtual const char *GetDefaultRelocationModel() const;
424  virtual const char *GetForcedPicModel() const;
425
426  virtual void AddClangSystemIncludeArgs(const ArgList &DriverArgs,
427                                         ArgStringList &CC1Args) const;
428  virtual void AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
429                                            ArgStringList &CC1Args) const;
430
431};
432
433} // end namespace toolchains
434} // end namespace driver
435} // end namespace clang
436
437#endif
438