contrib/llvm/tools/clang/lib/Driver/ToolChains/Darwin.h

   1 //===--- Darwin.h - Darwin 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 LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_DARWIN_H
  11 #define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_DARWIN_H
  12
  13 #include "Cuda.h"
  14 #include "clang/Driver/Tool.h"
  15 #include "clang/Driver/ToolChain.h"
  16
  17 namespace clang {
  18 namespace driver {
  19
  20 namespace toolchains {
  21 class MachO;
  22 } // end namespace toolchains
  23
  24 namespace tools {
  25
  26 namespace darwin {
  27 llvm::Triple::ArchType getArchTypeForMachOArchName(StringRef Str);
  28 void setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str);
  29
  30 class LLVM_LIBRARY_VISIBILITY MachOTool : public Tool {
  31   virtual void anchor();
  32
  33 protected:
  34   void AddMachOArch(const llvm::opt::ArgList &Args,
  35                     llvm::opt::ArgStringList &CmdArgs) const;
  36
  37   const toolchains::MachO &getMachOToolChain() const {
  38     return reinterpret_cast<const toolchains::MachO &>(getToolChain());
  39   }
  40
  41 public:
  42   MachOTool(
  43       const char *Name, const char *ShortName, const ToolChain &TC,
  44       ResponseFileSupport ResponseSupport = RF_None,
  45       llvm::sys::WindowsEncodingMethod ResponseEncoding = llvm::sys::WEM_UTF8,
  46       const char *ResponseFlag = "@")
  47       : Tool(Name, ShortName, TC, ResponseSupport, ResponseEncoding,
  48              ResponseFlag) {}
  49 };
  50
  51 class LLVM_LIBRARY_VISIBILITY Assembler : public MachOTool {
  52 public:
  53   Assembler(const ToolChain &TC)
  54       : MachOTool("darwin::Assembler", "assembler", TC) {}
  55
  56   bool hasIntegratedCPP() const override { return false; }
  57
  58   void ConstructJob(Compilation &C, const JobAction &JA,
  59                     const InputInfo &Output, const InputInfoList &Inputs,
  60                     const llvm::opt::ArgList &TCArgs,
  61                     const char *LinkingOutput) const override;
  62 };
  63
  64 class LLVM_LIBRARY_VISIBILITY Linker : public MachOTool {
  65   bool NeedsTempPath(const InputInfoList &Inputs) const;
  66   void AddLinkArgs(Compilation &C, const llvm::opt::ArgList &Args,
  67                    llvm::opt::ArgStringList &CmdArgs,
  68                    const InputInfoList &Inputs) const;
  69
  70 public:
  71   Linker(const ToolChain &TC)
  72       : MachOTool("darwin::Linker", "linker", TC, RF_FileList,
  73                   llvm::sys::WEM_UTF8, "-filelist") {}
  74
  75   bool hasIntegratedCPP() const override { return false; }
  76   bool isLinkJob() const override { return true; }
  77
  78   void ConstructJob(Compilation &C, const JobAction &JA,
  79                     const InputInfo &Output, const InputInfoList &Inputs,
  80                     const llvm::opt::ArgList &TCArgs,
  81                     const char *LinkingOutput) const override;
  82 };
  83
  84 class LLVM_LIBRARY_VISIBILITY Lipo : public MachOTool {
  85 public:
  86   Lipo(const ToolChain &TC) : MachOTool("darwin::Lipo", "lipo", TC) {}
  87
  88   bool hasIntegratedCPP() const override { return false; }
  89
  90   void ConstructJob(Compilation &C, const JobAction &JA,
  91                     const InputInfo &Output, const InputInfoList &Inputs,
  92                     const llvm::opt::ArgList &TCArgs,
  93                     const char *LinkingOutput) const override;
  94 };
  95
  96 class LLVM_LIBRARY_VISIBILITY Dsymutil : public MachOTool {
  97 public:
  98   Dsymutil(const ToolChain &TC)
  99       : MachOTool("darwin::Dsymutil", "dsymutil", TC) {}
 100
 101   bool hasIntegratedCPP() const override { return false; }
 102   bool isDsymutilJob() const override { return true; }
 103
 104   void ConstructJob(Compilation &C, const JobAction &JA,
 105                     const InputInfo &Output, const InputInfoList &Inputs,
 106                     const llvm::opt::ArgList &TCArgs,
 107                     const char *LinkingOutput) const override;
 108 };
 109
 110 class LLVM_LIBRARY_VISIBILITY VerifyDebug : public MachOTool {
 111 public:
 112   VerifyDebug(const ToolChain &TC)
 113       : MachOTool("darwin::VerifyDebug", "dwarfdump", TC) {}
 114
 115   bool hasIntegratedCPP() const override { return false; }
 116
 117   void ConstructJob(Compilation &C, const JobAction &JA,
 118                     const InputInfo &Output, const InputInfoList &Inputs,
 119                     const llvm::opt::ArgList &TCArgs,
 120                     const char *LinkingOutput) const override;
 121 };
 122 } // end namespace darwin
 123 } // end namespace tools
 124
 125 namespace toolchains {
 126
 127 class LLVM_LIBRARY_VISIBILITY MachO : public ToolChain {
 128 protected:
 129   Tool *buildAssembler() const override;
 130   Tool *buildLinker() const override;
 131   Tool *getTool(Action::ActionClass AC) const override;
 132
 133 private:
 134   mutable std::unique_ptr<tools::darwin::Lipo> Lipo;
 135   mutable std::unique_ptr<tools::darwin::Dsymutil> Dsymutil;
 136   mutable std::unique_ptr<tools::darwin::VerifyDebug> VerifyDebug;
 137
 138 public:
 139   MachO(const Driver &D, const llvm::Triple &Triple,
 140         const llvm::opt::ArgList &Args);
 141   ~MachO() override;
 142
 143   /// @name MachO specific toolchain API
 144   /// {
 145
 146   /// Get the "MachO" arch name for a particular compiler invocation. For
 147   /// example, Apple treats different ARM variations as distinct architectures.
 148   StringRef getMachOArchName(const llvm::opt::ArgList &Args) const;
 149
 150   /// Add the linker arguments to link the ARC runtime library.
 151   virtual void AddLinkARCArgs(const llvm::opt::ArgList &Args,
 152                               llvm::opt::ArgStringList &CmdArgs) const {}
 153
 154   /// Add the linker arguments to link the compiler runtime library.
 155   virtual void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args,
 156                                      llvm::opt::ArgStringList &CmdArgs) const;
 157
 158   virtual void addStartObjectFileArgs(const llvm::opt::ArgList &Args,
 159                                       llvm::opt::ArgStringList &CmdArgs) const {
 160   }
 161
 162   virtual void addMinVersionArgs(const llvm::opt::ArgList &Args,
 163                                  llvm::opt::ArgStringList &CmdArgs) const {}
 164
 165   /// On some iOS platforms, kernel and kernel modules were built statically. Is
 166   /// this such a target?
 167   virtual bool isKernelStatic() const { return false; }
 168
 169   /// Is the target either iOS or an iOS simulator?
 170   bool isTargetIOSBased() const { return false; }
 171
 172   void AddLinkRuntimeLib(const llvm::opt::ArgList &Args,
 173                          llvm::opt::ArgStringList &CmdArgs,
 174                          StringRef DarwinLibName, bool AlwaysLink = false,
 175                          bool IsEmbedded = false, bool AddRPath = false) const;
 176
 177   /// Add any profiling runtime libraries that are needed. This is essentially a
 178   /// MachO specific version of addProfileRT in Tools.cpp.
 179   void addProfileRTLibs(const llvm::opt::ArgList &Args,
 180                         llvm::opt::ArgStringList &CmdArgs) const override {
 181     // There aren't any profiling libs for embedded targets currently.
 182   }
 183
 184   /// }
 185   /// @name ToolChain Implementation
 186   /// {
 187
 188   types::ID LookupTypeForExtension(StringRef Ext) const override;
 189
 190   bool HasNativeLLVMSupport() const override;
 191
 192   llvm::opt::DerivedArgList *
 193   TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
 194                 Action::OffloadKind DeviceOffloadKind) const override;
 195
 196   bool IsBlocksDefault() const override {
 197     // Always allow blocks on Apple; users interested in versioning are
 198     // expected to use /usr/include/Block.h.
 199     return true;
 200   }
 201   bool IsIntegratedAssemblerDefault() const override {
 202     // Default integrated assembler to on for Apple's MachO targets.
 203     return true;
 204   }
 205
 206   bool IsMathErrnoDefault() const override { return false; }
 207
 208   bool IsEncodeExtendedBlockSignatureDefault() const override { return true; }
 209
 210   bool IsObjCNonFragileABIDefault() const override {
 211     // Non-fragile ABI is default for everything but i386.
 212     return getTriple().getArch() != llvm::Triple::x86;
 213   }
 214
 215   bool UseObjCMixedDispatch() const override { return true; }
 216
 217   bool IsUnwindTablesDefault() const override;
 218
 219   RuntimeLibType GetDefaultRuntimeLibType() const override {
 220     return ToolChain::RLT_CompilerRT;
 221   }
 222
 223   bool isPICDefault() const override;
 224   bool isPIEDefault() const override;
 225   bool isPICDefaultForced() const override;
 226
 227   bool SupportsProfiling() const override;
 228
 229   bool SupportsObjCGC() const override { return false; }
 230
 231   bool UseDwarfDebugFlags() const override;
 232
 233   bool UseSjLjExceptions(const llvm::opt::ArgList &Args) const override {
 234     return false;
 235   }
 236
 237   /// }
 238 };
 239
 240 /// Darwin - The base Darwin tool chain.
 241 class LLVM_LIBRARY_VISIBILITY Darwin : public MachO {
 242 public:
 243   /// Whether the information on the target has been initialized.
 244   //
 245   // FIXME: This should be eliminated. What we want to do is make this part of
 246   // the "default target for arguments" selection process, once we get out of
 247   // the argument translation business.
 248   mutable bool TargetInitialized;
 249
 250   enum DarwinPlatformKind {
 251     MacOS,
 252     IPhoneOS,
 253     IPhoneOSSimulator,
 254     TvOS,
 255     TvOSSimulator,
 256     WatchOS,
 257     WatchOSSimulator
 258   };
 259
 260   mutable DarwinPlatformKind TargetPlatform;
 261
 262   /// The OS version we are targeting.
 263   mutable VersionTuple TargetVersion;
 264
 265   CudaInstallationDetector CudaInstallation;
 266
 267 private:
 268   void AddDeploymentTarget(llvm::opt::DerivedArgList &Args) const;
 269
 270 public:
 271   Darwin(const Driver &D, const llvm::Triple &Triple,
 272          const llvm::opt::ArgList &Args);
 273   ~Darwin() override;
 274
 275   std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
 276                                           types::ID InputType) const override;
 277
 278   /// @name Apple Specific Toolchain Implementation
 279   /// {
 280
 281   void addMinVersionArgs(const llvm::opt::ArgList &Args,
 282                          llvm::opt::ArgStringList &CmdArgs) const override;
 283
 284   void addStartObjectFileArgs(const llvm::opt::ArgList &Args,
 285                               llvm::opt::ArgStringList &CmdArgs) const override;
 286
 287   bool isKernelStatic() const override {
 288     return (!(isTargetIPhoneOS() && !isIPhoneOSVersionLT(6, 0)) &&
 289             !isTargetWatchOS());
 290   }
 291
 292   void addProfileRTLibs(const llvm::opt::ArgList &Args,
 293                         llvm::opt::ArgStringList &CmdArgs) const override;
 294
 295 protected:
 296   /// }
 297   /// @name Darwin specific Toolchain functions
 298   /// {
 299
 300   // FIXME: Eliminate these ...Target functions and derive separate tool chains
 301   // for these targets and put version in constructor.
 302   void setTarget(DarwinPlatformKind Platform, unsigned Major, unsigned Minor,
 303                  unsigned Micro) const {
 304     // FIXME: For now, allow reinitialization as long as values don't
 305     // change. This will go away when we move away from argument translation.
 306     if (TargetInitialized && TargetPlatform == Platform &&
 307         TargetVersion == VersionTuple(Major, Minor, Micro))
 308       return;
 309
 310     assert(!TargetInitialized && "Target already initialized!");
 311     TargetInitialized = true;
 312     TargetPlatform = Platform;
 313     TargetVersion = VersionTuple(Major, Minor, Micro);
 314   }
 315
 316   bool isTargetIPhoneOS() const {
 317     assert(TargetInitialized && "Target not initialized!");
 318     return TargetPlatform == IPhoneOS || TargetPlatform == TvOS;
 319   }
 320
 321   bool isTargetIOSSimulator() const {
 322     assert(TargetInitialized && "Target not initialized!");
 323     return TargetPlatform == IPhoneOSSimulator ||
 324            TargetPlatform == TvOSSimulator;
 325   }
 326
 327   bool isTargetIOSBased() const {
 328     assert(TargetInitialized && "Target not initialized!");
 329     return isTargetIPhoneOS() || isTargetIOSSimulator();
 330   }
 331
 332   bool isTargetTvOS() const {
 333     assert(TargetInitialized && "Target not initialized!");
 334     return TargetPlatform == TvOS;
 335   }
 336
 337   bool isTargetTvOSSimulator() const {
 338     assert(TargetInitialized && "Target not initialized!");
 339     return TargetPlatform == TvOSSimulator;
 340   }
 341
 342   bool isTargetTvOSBased() const {
 343     assert(TargetInitialized && "Target not initialized!");
 344     return TargetPlatform == TvOS || TargetPlatform == TvOSSimulator;
 345   }
 346
 347   bool isTargetWatchOS() const {
 348     assert(TargetInitialized && "Target not initialized!");
 349     return TargetPlatform == WatchOS;
 350   }
 351
 352   bool isTargetWatchOSSimulator() const {
 353     assert(TargetInitialized && "Target not initialized!");
 354     return TargetPlatform == WatchOSSimulator;
 355   }
 356
 357   bool isTargetWatchOSBased() const {
 358     assert(TargetInitialized && "Target not initialized!");
 359     return TargetPlatform == WatchOS || TargetPlatform == WatchOSSimulator;
 360   }
 361
 362   bool isTargetMacOS() const {
 363     assert(TargetInitialized && "Target not initialized!");
 364     return TargetPlatform == MacOS;
 365   }
 366
 367   bool isTargetInitialized() const { return TargetInitialized; }
 368
 369   VersionTuple getTargetVersion() const {
 370     assert(TargetInitialized && "Target not initialized!");
 371     return TargetVersion;
 372   }
 373
 374   bool isIPhoneOSVersionLT(unsigned V0, unsigned V1 = 0,
 375                            unsigned V2 = 0) const {
 376     assert(isTargetIOSBased() && "Unexpected call for non iOS target!");
 377     return TargetVersion < VersionTuple(V0, V1, V2);
 378   }
 379
 380   bool isMacosxVersionLT(unsigned V0, unsigned V1 = 0, unsigned V2 = 0) const {
 381     assert(isTargetMacOS() && "Unexpected call for non OS X target!");
 382     return TargetVersion < VersionTuple(V0, V1, V2);
 383   }
 384
 385   StringRef getPlatformFamily() const;
 386   static StringRef getSDKName(StringRef isysroot);
 387   StringRef getOSLibraryNameSuffix() const;
 388
 389 public:
 390   /// }
 391   /// @name ToolChain Implementation
 392   /// {
 393
 394   // Darwin tools support multiple architecture (e.g., i386 and x86_64) and
 395   // most development is done against SDKs, so compiling for a different
 396   // architecture should not get any special treatment.
 397   bool isCrossCompiling() const override { return false; }
 398
 399   llvm::opt::DerivedArgList *
 400   TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
 401                 Action::OffloadKind DeviceOffloadKind) const override;
 402
 403   CXXStdlibType GetDefaultCXXStdlibType() const override;
 404   ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const override;
 405   bool hasBlocksRuntime() const override;
 406
 407   void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
 408                           llvm::opt::ArgStringList &CC1Args) const override;
 409
 410   bool UseObjCMixedDispatch() const override {
 411     // This is only used with the non-fragile ABI and non-legacy dispatch.
 412
 413     // Mixed dispatch is used everywhere except OS X before 10.6.
 414     return !(isTargetMacOS() && isMacosxVersionLT(10, 6));
 415   }
 416
 417   unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
 418     // Stack protectors default to on for user code on 10.5,
 419     // and for everything in 10.6 and beyond
 420     if (isTargetIOSBased() || isTargetWatchOSBased())
 421       return 1;
 422     else if (isTargetMacOS() && !isMacosxVersionLT(10, 6))
 423       return 1;
 424     else if (isTargetMacOS() && !isMacosxVersionLT(10, 5) && !KernelOrKext)
 425       return 1;
 426
 427     return 0;
 428   }
 429
 430   bool SupportsObjCGC() const override;
 431
 432   void CheckObjCARC() const override;
 433
 434   bool UseSjLjExceptions(const llvm::opt::ArgList &Args) const override;
 435
 436   bool SupportsEmbeddedBitcode() const override;
 437
 438   SanitizerMask getSupportedSanitizers() const override;
 439
 440   void printVerboseInfo(raw_ostream &OS) const override;
 441 };
 442
 443 /// DarwinClang - The Darwin toolchain used by Clang.
 444 class LLVM_LIBRARY_VISIBILITY DarwinClang : public Darwin {
 445 public:
 446   DarwinClang(const Driver &D, const llvm::Triple &Triple,
 447               const llvm::opt::ArgList &Args);
 448
 449   /// @name Apple ToolChain Implementation
 450   /// {
 451
 452   RuntimeLibType GetRuntimeLibType(const llvm::opt::ArgList &Args) const override;
 453
 454   void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args,
 455                              llvm::opt::ArgStringList &CmdArgs) const override;
 456
 457   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
 458                            llvm::opt::ArgStringList &CmdArgs) const override;
 459
 460   void AddCCKextLibArgs(const llvm::opt::ArgList &Args,
 461                         llvm::opt::ArgStringList &CmdArgs) const override;
 462
 463   void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const override;
 464
 465   void AddLinkARCArgs(const llvm::opt::ArgList &Args,
 466                       llvm::opt::ArgStringList &CmdArgs) const override;
 467
 468   unsigned GetDefaultDwarfVersion() const override;
 469   // Until dtrace (via CTF) and LLDB can deal with distributed debug info,
 470   // Darwin defaults to standalone/full debug info.
 471   bool GetDefaultStandaloneDebug() const override { return true; }
 472   llvm::DebuggerKind getDefaultDebuggerTuning() const override {
 473     return llvm::DebuggerKind::LLDB;
 474   }
 475
 476   /// }
 477
 478 private:
 479   void AddLinkSanitizerLibArgs(const llvm::opt::ArgList &Args,
 480                                llvm::opt::ArgStringList &CmdArgs,
 481                                StringRef Sanitizer) const;
 482 };
 483
 484 } // end namespace toolchains
 485 } // end namespace driver
 486 } // end namespace clang
 487
 488 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_DARWIN_H