Darwin.cpp revision 322855
1//===--- Darwin.cpp - Darwin Tool and 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#include "Darwin.h" 11#include "Arch/ARM.h" 12#include "CommonArgs.h" 13#include "clang/Basic/ObjCRuntime.h" 14#include "clang/Basic/VirtualFileSystem.h" 15#include "clang/Driver/Compilation.h" 16#include "clang/Driver/Driver.h" 17#include "clang/Driver/DriverDiagnostic.h" 18#include "clang/Driver/Options.h" 19#include "clang/Driver/SanitizerArgs.h" 20#include "llvm/ADT/StringSwitch.h" 21#include "llvm/Option/ArgList.h" 22#include "llvm/Support/Path.h" 23#include "llvm/Support/ScopedPrinter.h" 24#include "llvm/Support/TargetParser.h" 25#include <cstdlib> // ::getenv 26 27using namespace clang::driver; 28using namespace clang::driver::tools; 29using namespace clang::driver::toolchains; 30using namespace clang; 31using namespace llvm::opt; 32 33llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) { 34 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for 35 // archs which Darwin doesn't use. 36 37 // The matching this routine does is fairly pointless, since it is neither the 38 // complete architecture list, nor a reasonable subset. The problem is that 39 // historically the driver driver accepts this and also ties its -march= 40 // handling to the architecture name, so we need to be careful before removing 41 // support for it. 42 43 // This code must be kept in sync with Clang's Darwin specific argument 44 // translation. 45 46 return llvm::StringSwitch<llvm::Triple::ArchType>(Str) 47 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc) 48 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc) 49 .Case("ppc64", llvm::Triple::ppc64) 50 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86) 51 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4", 52 llvm::Triple::x86) 53 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64) 54 // This is derived from the driver driver. 55 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm) 56 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm) 57 .Cases("armv7s", "xscale", llvm::Triple::arm) 58 .Case("arm64", llvm::Triple::aarch64) 59 .Case("r600", llvm::Triple::r600) 60 .Case("amdgcn", llvm::Triple::amdgcn) 61 .Case("nvptx", llvm::Triple::nvptx) 62 .Case("nvptx64", llvm::Triple::nvptx64) 63 .Case("amdil", llvm::Triple::amdil) 64 .Case("spir", llvm::Triple::spir) 65 .Default(llvm::Triple::UnknownArch); 66} 67 68void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) { 69 const llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str); 70 unsigned ArchKind = llvm::ARM::parseArch(Str); 71 T.setArch(Arch); 72 73 if (Str == "x86_64h") 74 T.setArchName(Str); 75 else if (ArchKind == llvm::ARM::AK_ARMV6M || 76 ArchKind == llvm::ARM::AK_ARMV7M || 77 ArchKind == llvm::ARM::AK_ARMV7EM) { 78 T.setOS(llvm::Triple::UnknownOS); 79 T.setObjectFormat(llvm::Triple::MachO); 80 } 81} 82 83void darwin::Assembler::ConstructJob(Compilation &C, const JobAction &JA, 84 const InputInfo &Output, 85 const InputInfoList &Inputs, 86 const ArgList &Args, 87 const char *LinkingOutput) const { 88 ArgStringList CmdArgs; 89 90 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 91 const InputInfo &Input = Inputs[0]; 92 93 // Determine the original source input. 94 const Action *SourceAction = &JA; 95 while (SourceAction->getKind() != Action::InputClass) { 96 assert(!SourceAction->getInputs().empty() && "unexpected root action!"); 97 SourceAction = SourceAction->getInputs()[0]; 98 } 99 100 // If -fno-integrated-as is used add -Q to the darwin assember driver to make 101 // sure it runs its system assembler not clang's integrated assembler. 102 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as. 103 // FIXME: at run-time detect assembler capabilities or rely on version 104 // information forwarded by -target-assembler-version. 105 if (Args.hasArg(options::OPT_fno_integrated_as)) { 106 const llvm::Triple &T(getToolChain().getTriple()); 107 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7))) 108 CmdArgs.push_back("-Q"); 109 } 110 111 // Forward -g, assuming we are dealing with an actual assembly file. 112 if (SourceAction->getType() == types::TY_Asm || 113 SourceAction->getType() == types::TY_PP_Asm) { 114 if (Args.hasArg(options::OPT_gstabs)) 115 CmdArgs.push_back("--gstabs"); 116 else if (Args.hasArg(options::OPT_g_Group)) 117 CmdArgs.push_back("-g"); 118 } 119 120 // Derived from asm spec. 121 AddMachOArch(Args, CmdArgs); 122 123 // Use -force_cpusubtype_ALL on x86 by default. 124 if (getToolChain().getArch() == llvm::Triple::x86 || 125 getToolChain().getArch() == llvm::Triple::x86_64 || 126 Args.hasArg(options::OPT_force__cpusubtype__ALL)) 127 CmdArgs.push_back("-force_cpusubtype_ALL"); 128 129 if (getToolChain().getArch() != llvm::Triple::x86_64 && 130 (((Args.hasArg(options::OPT_mkernel) || 131 Args.hasArg(options::OPT_fapple_kext)) && 132 getMachOToolChain().isKernelStatic()) || 133 Args.hasArg(options::OPT_static))) 134 CmdArgs.push_back("-static"); 135 136 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); 137 138 assert(Output.isFilename() && "Unexpected lipo output."); 139 CmdArgs.push_back("-o"); 140 CmdArgs.push_back(Output.getFilename()); 141 142 assert(Input.isFilename() && "Invalid input."); 143 CmdArgs.push_back(Input.getFilename()); 144 145 // asm_final spec is empty. 146 147 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as")); 148 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs)); 149} 150 151void darwin::MachOTool::anchor() {} 152 153void darwin::MachOTool::AddMachOArch(const ArgList &Args, 154 ArgStringList &CmdArgs) const { 155 StringRef ArchName = getMachOToolChain().getMachOArchName(Args); 156 157 // Derived from darwin_arch spec. 158 CmdArgs.push_back("-arch"); 159 CmdArgs.push_back(Args.MakeArgString(ArchName)); 160 161 // FIXME: Is this needed anymore? 162 if (ArchName == "arm") 163 CmdArgs.push_back("-force_cpusubtype_ALL"); 164} 165 166bool darwin::Linker::NeedsTempPath(const InputInfoList &Inputs) const { 167 // We only need to generate a temp path for LTO if we aren't compiling object 168 // files. When compiling source files, we run 'dsymutil' after linking. We 169 // don't run 'dsymutil' when compiling object files. 170 for (const auto &Input : Inputs) 171 if (Input.getType() != types::TY_Object) 172 return true; 173 174 return false; 175} 176 177/// \brief Pass -no_deduplicate to ld64 under certain conditions: 178/// 179/// - Either -O0 or -O1 is explicitly specified 180/// - No -O option is specified *and* this is a compile+link (implicit -O0) 181/// 182/// Also do *not* add -no_deduplicate when no -O option is specified and this 183/// is just a link (we can't imply -O0) 184static bool shouldLinkerNotDedup(bool IsLinkerOnlyAction, const ArgList &Args) { 185 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 186 if (A->getOption().matches(options::OPT_O0)) 187 return true; 188 if (A->getOption().matches(options::OPT_O)) 189 return llvm::StringSwitch<bool>(A->getValue()) 190 .Case("1", true) 191 .Default(false); 192 return false; // OPT_Ofast & OPT_O4 193 } 194 195 if (!IsLinkerOnlyAction) // Implicit -O0 for compile+linker only. 196 return true; 197 return false; 198} 199 200void darwin::Linker::AddLinkArgs(Compilation &C, const ArgList &Args, 201 ArgStringList &CmdArgs, 202 const InputInfoList &Inputs) const { 203 const Driver &D = getToolChain().getDriver(); 204 const toolchains::MachO &MachOTC = getMachOToolChain(); 205 206 unsigned Version[5] = {0, 0, 0, 0, 0}; 207 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) { 208 if (!Driver::GetReleaseVersion(A->getValue(), Version)) 209 D.Diag(diag::err_drv_invalid_version_number) << A->getAsString(Args); 210 } 211 212 // Newer linkers support -demangle. Pass it if supported and not disabled by 213 // the user. 214 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) 215 CmdArgs.push_back("-demangle"); 216 217 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137) 218 CmdArgs.push_back("-export_dynamic"); 219 220 // If we are using App Extension restrictions, pass a flag to the linker 221 // telling it that the compiled code has been audited. 222 if (Args.hasFlag(options::OPT_fapplication_extension, 223 options::OPT_fno_application_extension, false)) 224 CmdArgs.push_back("-application_extension"); 225 226 if (D.isUsingLTO()) { 227 // If we are using LTO, then automatically create a temporary file path for 228 // the linker to use, so that it's lifetime will extend past a possible 229 // dsymutil step. 230 if (Version[0] >= 116 && NeedsTempPath(Inputs)) { 231 const char *TmpPath = C.getArgs().MakeArgString( 232 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object))); 233 C.addTempFile(TmpPath); 234 CmdArgs.push_back("-object_path_lto"); 235 CmdArgs.push_back(TmpPath); 236 } 237 } 238 239 // Use -lto_library option to specify the libLTO.dylib path. Try to find 240 // it in clang installed libraries. ld64 will only look at this argument 241 // when it actually uses LTO, so libLTO.dylib only needs to exist at link 242 // time if ld64 decides that it needs to use LTO. 243 // Since this is passed unconditionally, ld64 will never look for libLTO.dylib 244 // next to it. That's ok since ld64 using a libLTO.dylib not matching the 245 // clang version won't work anyways. 246 if (Version[0] >= 133) { 247 // Search for libLTO in <InstalledDir>/../lib/libLTO.dylib 248 StringRef P = llvm::sys::path::parent_path(D.Dir); 249 SmallString<128> LibLTOPath(P); 250 llvm::sys::path::append(LibLTOPath, "lib"); 251 llvm::sys::path::append(LibLTOPath, "libLTO.dylib"); 252 CmdArgs.push_back("-lto_library"); 253 CmdArgs.push_back(C.getArgs().MakeArgString(LibLTOPath)); 254 } 255 256 // ld64 version 262 and above run the deduplicate pass by default. 257 if (Version[0] >= 262 && shouldLinkerNotDedup(C.getJobs().empty(), Args)) 258 CmdArgs.push_back("-no_deduplicate"); 259 260 // Derived from the "link" spec. 261 Args.AddAllArgs(CmdArgs, options::OPT_static); 262 if (!Args.hasArg(options::OPT_static)) 263 CmdArgs.push_back("-dynamic"); 264 if (Args.hasArg(options::OPT_fgnu_runtime)) { 265 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu 266 // here. How do we wish to handle such things? 267 } 268 269 if (!Args.hasArg(options::OPT_dynamiclib)) { 270 AddMachOArch(Args, CmdArgs); 271 // FIXME: Why do this only on this path? 272 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL); 273 274 Args.AddLastArg(CmdArgs, options::OPT_bundle); 275 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader); 276 Args.AddAllArgs(CmdArgs, options::OPT_client__name); 277 278 Arg *A; 279 if ((A = Args.getLastArg(options::OPT_compatibility__version)) || 280 (A = Args.getLastArg(options::OPT_current__version)) || 281 (A = Args.getLastArg(options::OPT_install__name))) 282 D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args) 283 << "-dynamiclib"; 284 285 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace); 286 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs); 287 Args.AddLastArg(CmdArgs, options::OPT_private__bundle); 288 } else { 289 CmdArgs.push_back("-dylib"); 290 291 Arg *A; 292 if ((A = Args.getLastArg(options::OPT_bundle)) || 293 (A = Args.getLastArg(options::OPT_bundle__loader)) || 294 (A = Args.getLastArg(options::OPT_client__name)) || 295 (A = Args.getLastArg(options::OPT_force__flat__namespace)) || 296 (A = Args.getLastArg(options::OPT_keep__private__externs)) || 297 (A = Args.getLastArg(options::OPT_private__bundle))) 298 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args) 299 << "-dynamiclib"; 300 301 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version, 302 "-dylib_compatibility_version"); 303 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version, 304 "-dylib_current_version"); 305 306 AddMachOArch(Args, CmdArgs); 307 308 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name, 309 "-dylib_install_name"); 310 } 311 312 Args.AddLastArg(CmdArgs, options::OPT_all__load); 313 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client); 314 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load); 315 if (MachOTC.isTargetIOSBased()) 316 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal); 317 Args.AddLastArg(CmdArgs, options::OPT_dead__strip); 318 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms); 319 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file); 320 Args.AddLastArg(CmdArgs, options::OPT_dynamic); 321 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list); 322 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace); 323 Args.AddAllArgs(CmdArgs, options::OPT_force__load); 324 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names); 325 Args.AddAllArgs(CmdArgs, options::OPT_image__base); 326 Args.AddAllArgs(CmdArgs, options::OPT_init); 327 328 // Add the deployment target. 329 MachOTC.addMinVersionArgs(Args, CmdArgs); 330 331 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs); 332 Args.AddLastArg(CmdArgs, options::OPT_multi__module); 333 Args.AddLastArg(CmdArgs, options::OPT_single__module); 334 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined); 335 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused); 336 337 if (const Arg *A = 338 Args.getLastArg(options::OPT_fpie, options::OPT_fPIE, 339 options::OPT_fno_pie, options::OPT_fno_PIE)) { 340 if (A->getOption().matches(options::OPT_fpie) || 341 A->getOption().matches(options::OPT_fPIE)) 342 CmdArgs.push_back("-pie"); 343 else 344 CmdArgs.push_back("-no_pie"); 345 } 346 347 // for embed-bitcode, use -bitcode_bundle in linker command 348 if (C.getDriver().embedBitcodeEnabled()) { 349 // Check if the toolchain supports bitcode build flow. 350 if (MachOTC.SupportsEmbeddedBitcode()) { 351 CmdArgs.push_back("-bitcode_bundle"); 352 if (C.getDriver().embedBitcodeMarkerOnly() && Version[0] >= 278) { 353 CmdArgs.push_back("-bitcode_process_mode"); 354 CmdArgs.push_back("marker"); 355 } 356 } else 357 D.Diag(diag::err_drv_bitcode_unsupported_on_toolchain); 358 } 359 360 Args.AddLastArg(CmdArgs, options::OPT_prebind); 361 Args.AddLastArg(CmdArgs, options::OPT_noprebind); 362 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding); 363 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules); 364 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs); 365 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate); 366 Args.AddAllArgs(CmdArgs, options::OPT_sectorder); 367 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr); 368 Args.AddAllArgs(CmdArgs, options::OPT_segprot); 369 Args.AddAllArgs(CmdArgs, options::OPT_segaddr); 370 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr); 371 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr); 372 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table); 373 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename); 374 Args.AddAllArgs(CmdArgs, options::OPT_sub__library); 375 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella); 376 377 // Give --sysroot= preference, over the Apple specific behavior to also use 378 // --isysroot as the syslibroot. 379 StringRef sysroot = C.getSysRoot(); 380 if (sysroot != "") { 381 CmdArgs.push_back("-syslibroot"); 382 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot)); 383 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) { 384 CmdArgs.push_back("-syslibroot"); 385 CmdArgs.push_back(A->getValue()); 386 } 387 388 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace); 389 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints); 390 Args.AddAllArgs(CmdArgs, options::OPT_umbrella); 391 Args.AddAllArgs(CmdArgs, options::OPT_undefined); 392 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list); 393 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches); 394 Args.AddLastArg(CmdArgs, options::OPT_X_Flag); 395 Args.AddAllArgs(CmdArgs, options::OPT_y); 396 Args.AddLastArg(CmdArgs, options::OPT_w); 397 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size); 398 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__); 399 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit); 400 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit); 401 Args.AddAllArgs(CmdArgs, options::OPT_sectalign); 402 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols); 403 Args.AddAllArgs(CmdArgs, options::OPT_segcreate); 404 Args.AddLastArg(CmdArgs, options::OPT_whyload); 405 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded); 406 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name); 407 Args.AddLastArg(CmdArgs, options::OPT_dylinker); 408 Args.AddLastArg(CmdArgs, options::OPT_Mach); 409} 410 411/// \brief Determine whether we are linking the ObjC runtime. 412static bool isObjCRuntimeLinked(const ArgList &Args) { 413 if (isObjCAutoRefCount(Args)) { 414 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime); 415 return true; 416 } 417 return Args.hasArg(options::OPT_fobjc_link_runtime); 418} 419 420void darwin::Linker::ConstructJob(Compilation &C, const JobAction &JA, 421 const InputInfo &Output, 422 const InputInfoList &Inputs, 423 const ArgList &Args, 424 const char *LinkingOutput) const { 425 assert(Output.getType() == types::TY_Image && "Invalid linker output type."); 426 427 // If the number of arguments surpasses the system limits, we will encode the 428 // input files in a separate file, shortening the command line. To this end, 429 // build a list of input file names that can be passed via a file with the 430 // -filelist linker option. 431 llvm::opt::ArgStringList InputFileList; 432 433 // The logic here is derived from gcc's behavior; most of which 434 // comes from specs (starting with link_command). Consult gcc for 435 // more information. 436 ArgStringList CmdArgs; 437 438 /// Hack(tm) to ignore linking errors when we are doing ARC migration. 439 if (Args.hasArg(options::OPT_ccc_arcmt_check, 440 options::OPT_ccc_arcmt_migrate)) { 441 for (const auto &Arg : Args) 442 Arg->claim(); 443 const char *Exec = 444 Args.MakeArgString(getToolChain().GetProgramPath("touch")); 445 CmdArgs.push_back(Output.getFilename()); 446 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, None)); 447 return; 448 } 449 450 // I'm not sure why this particular decomposition exists in gcc, but 451 // we follow suite for ease of comparison. 452 AddLinkArgs(C, Args, CmdArgs, Inputs); 453 454 // For LTO, pass the name of the optimization record file. 455 if (Args.hasFlag(options::OPT_fsave_optimization_record, 456 options::OPT_fno_save_optimization_record, false)) { 457 CmdArgs.push_back("-mllvm"); 458 CmdArgs.push_back("-lto-pass-remarks-output"); 459 CmdArgs.push_back("-mllvm"); 460 461 SmallString<128> F; 462 F = Output.getFilename(); 463 F += ".opt.yaml"; 464 CmdArgs.push_back(Args.MakeArgString(F)); 465 466 if (getLastProfileUseArg(Args)) { 467 CmdArgs.push_back("-mllvm"); 468 CmdArgs.push_back("-lto-pass-remarks-with-hotness"); 469 } 470 } 471 472 // It seems that the 'e' option is completely ignored for dynamic executables 473 // (the default), and with static executables, the last one wins, as expected. 474 Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t, 475 options::OPT_Z_Flag, options::OPT_u_Group, 476 options::OPT_e, options::OPT_r}); 477 478 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading 479 // members of static archive libraries which implement Objective-C classes or 480 // categories. 481 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX)) 482 CmdArgs.push_back("-ObjC"); 483 484 CmdArgs.push_back("-o"); 485 CmdArgs.push_back(Output.getFilename()); 486 487 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) 488 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs); 489 490 // SafeStack requires its own runtime libraries 491 // These libraries should be linked first, to make sure the 492 // __safestack_init constructor executes before everything else 493 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) { 494 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs, 495 "libclang_rt.safestack_osx.a", 496 /*AlwaysLink=*/true); 497 } 498 499 Args.AddAllArgs(CmdArgs, options::OPT_L); 500 501 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA); 502 // Build the input file for -filelist (list of linker input files) in case we 503 // need it later 504 for (const auto &II : Inputs) { 505 if (!II.isFilename()) { 506 // This is a linker input argument. 507 // We cannot mix input arguments and file names in a -filelist input, thus 508 // we prematurely stop our list (remaining files shall be passed as 509 // arguments). 510 if (InputFileList.size() > 0) 511 break; 512 513 continue; 514 } 515 516 InputFileList.push_back(II.getFilename()); 517 } 518 519 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) 520 addOpenMPRuntime(CmdArgs, getToolChain(), Args); 521 522 if (isObjCRuntimeLinked(Args) && 523 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) { 524 // We use arclite library for both ARC and subscripting support. 525 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs); 526 527 CmdArgs.push_back("-framework"); 528 CmdArgs.push_back("Foundation"); 529 // Link libobj. 530 CmdArgs.push_back("-lobjc"); 531 } 532 533 if (LinkingOutput) { 534 CmdArgs.push_back("-arch_multiple"); 535 CmdArgs.push_back("-final_output"); 536 CmdArgs.push_back(LinkingOutput); 537 } 538 539 if (Args.hasArg(options::OPT_fnested_functions)) 540 CmdArgs.push_back("-allow_stack_execute"); 541 542 getMachOToolChain().addProfileRTLibs(Args, CmdArgs); 543 544 if (unsigned Parallelism = 545 getLTOParallelism(Args, getToolChain().getDriver())) { 546 CmdArgs.push_back("-mllvm"); 547 CmdArgs.push_back( 548 Args.MakeArgString(Twine("-threads=") + llvm::to_string(Parallelism))); 549 } 550 551 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) { 552 if (getToolChain().getDriver().CCCIsCXX()) 553 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 554 555 // link_ssp spec is empty. 556 557 // Let the tool chain choose which runtime library to link. 558 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs); 559 560 // No need to do anything for pthreads. Claim argument to avoid warning. 561 Args.ClaimAllArgs(options::OPT_pthread); 562 Args.ClaimAllArgs(options::OPT_pthreads); 563 } 564 565 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) { 566 // endfile_spec is empty. 567 } 568 569 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 570 Args.AddAllArgs(CmdArgs, options::OPT_F); 571 572 // -iframework should be forwarded as -F. 573 for (const Arg *A : Args.filtered(options::OPT_iframework)) 574 CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue())); 575 576 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) { 577 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) { 578 if (A->getValue() == StringRef("Accelerate")) { 579 CmdArgs.push_back("-framework"); 580 CmdArgs.push_back("Accelerate"); 581 } 582 } 583 } 584 585 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath()); 586 std::unique_ptr<Command> Cmd = 587 llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs); 588 Cmd->setInputFileList(std::move(InputFileList)); 589 C.addCommand(std::move(Cmd)); 590} 591 592void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA, 593 const InputInfo &Output, 594 const InputInfoList &Inputs, 595 const ArgList &Args, 596 const char *LinkingOutput) const { 597 ArgStringList CmdArgs; 598 599 CmdArgs.push_back("-create"); 600 assert(Output.isFilename() && "Unexpected lipo output."); 601 602 CmdArgs.push_back("-output"); 603 CmdArgs.push_back(Output.getFilename()); 604 605 for (const auto &II : Inputs) { 606 assert(II.isFilename() && "Unexpected lipo input."); 607 CmdArgs.push_back(II.getFilename()); 608 } 609 610 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo")); 611 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs)); 612} 613 614void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA, 615 const InputInfo &Output, 616 const InputInfoList &Inputs, 617 const ArgList &Args, 618 const char *LinkingOutput) const { 619 ArgStringList CmdArgs; 620 621 CmdArgs.push_back("-o"); 622 CmdArgs.push_back(Output.getFilename()); 623 624 assert(Inputs.size() == 1 && "Unable to handle multiple inputs."); 625 const InputInfo &Input = Inputs[0]; 626 assert(Input.isFilename() && "Unexpected dsymutil input."); 627 CmdArgs.push_back(Input.getFilename()); 628 629 const char *Exec = 630 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil")); 631 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs)); 632} 633 634void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA, 635 const InputInfo &Output, 636 const InputInfoList &Inputs, 637 const ArgList &Args, 638 const char *LinkingOutput) const { 639 ArgStringList CmdArgs; 640 CmdArgs.push_back("--verify"); 641 CmdArgs.push_back("--debug-info"); 642 CmdArgs.push_back("--eh-frame"); 643 CmdArgs.push_back("--quiet"); 644 645 assert(Inputs.size() == 1 && "Unable to handle multiple inputs."); 646 const InputInfo &Input = Inputs[0]; 647 assert(Input.isFilename() && "Unexpected verify input"); 648 649 // Grabbing the output of the earlier dsymutil run. 650 CmdArgs.push_back(Input.getFilename()); 651 652 const char *Exec = 653 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump")); 654 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs)); 655} 656 657MachO::MachO(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) 658 : ToolChain(D, Triple, Args) { 659 // We expect 'as', 'ld', etc. to be adjacent to our install dir. 660 getProgramPaths().push_back(getDriver().getInstalledDir()); 661 if (getDriver().getInstalledDir() != getDriver().Dir) 662 getProgramPaths().push_back(getDriver().Dir); 663} 664 665/// Darwin - Darwin tool chain for i386 and x86_64. 666Darwin::Darwin(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) 667 : MachO(D, Triple, Args), TargetInitialized(false), 668 CudaInstallation(D, Triple, Args) {} 669 670types::ID MachO::LookupTypeForExtension(StringRef Ext) const { 671 types::ID Ty = types::lookupTypeForExtension(Ext); 672 673 // Darwin always preprocesses assembly files (unless -x is used explicitly). 674 if (Ty == types::TY_PP_Asm) 675 return types::TY_Asm; 676 677 return Ty; 678} 679 680bool MachO::HasNativeLLVMSupport() const { return true; } 681 682ToolChain::CXXStdlibType Darwin::GetDefaultCXXStdlibType() const { 683 // Default to use libc++ on OS X 10.9+ and iOS 7+. 684 if ((isTargetMacOS() && !isMacosxVersionLT(10, 9)) || 685 (isTargetIOSBased() && !isIPhoneOSVersionLT(7, 0)) || 686 isTargetWatchOSBased()) 687 return ToolChain::CST_Libcxx; 688 689 return ToolChain::CST_Libstdcxx; 690} 691 692/// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0. 693ObjCRuntime Darwin::getDefaultObjCRuntime(bool isNonFragile) const { 694 if (isTargetWatchOSBased()) 695 return ObjCRuntime(ObjCRuntime::WatchOS, TargetVersion); 696 if (isTargetIOSBased()) 697 return ObjCRuntime(ObjCRuntime::iOS, TargetVersion); 698 if (isNonFragile) 699 return ObjCRuntime(ObjCRuntime::MacOSX, TargetVersion); 700 return ObjCRuntime(ObjCRuntime::FragileMacOSX, TargetVersion); 701} 702 703/// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2. 704bool Darwin::hasBlocksRuntime() const { 705 if (isTargetWatchOSBased()) 706 return true; 707 else if (isTargetIOSBased()) 708 return !isIPhoneOSVersionLT(3, 2); 709 else { 710 assert(isTargetMacOS() && "unexpected darwin target"); 711 return !isMacosxVersionLT(10, 6); 712 } 713} 714 715void Darwin::AddCudaIncludeArgs(const ArgList &DriverArgs, 716 ArgStringList &CC1Args) const { 717 CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args); 718} 719 720// This is just a MachO name translation routine and there's no 721// way to join this into ARMTargetParser without breaking all 722// other assumptions. Maybe MachO should consider standardising 723// their nomenclature. 724static const char *ArmMachOArchName(StringRef Arch) { 725 return llvm::StringSwitch<const char *>(Arch) 726 .Case("armv6k", "armv6") 727 .Case("armv6m", "armv6m") 728 .Case("armv5tej", "armv5") 729 .Case("xscale", "xscale") 730 .Case("armv4t", "armv4t") 731 .Case("armv7", "armv7") 732 .Cases("armv7a", "armv7-a", "armv7") 733 .Cases("armv7r", "armv7-r", "armv7") 734 .Cases("armv7em", "armv7e-m", "armv7em") 735 .Cases("armv7k", "armv7-k", "armv7k") 736 .Cases("armv7m", "armv7-m", "armv7m") 737 .Cases("armv7s", "armv7-s", "armv7s") 738 .Default(nullptr); 739} 740 741static const char *ArmMachOArchNameCPU(StringRef CPU) { 742 unsigned ArchKind = llvm::ARM::parseCPUArch(CPU); 743 if (ArchKind == llvm::ARM::AK_INVALID) 744 return nullptr; 745 StringRef Arch = llvm::ARM::getArchName(ArchKind); 746 747 // FIXME: Make sure this MachO triple mangling is really necessary. 748 // ARMv5* normalises to ARMv5. 749 if (Arch.startswith("armv5")) 750 Arch = Arch.substr(0, 5); 751 // ARMv6*, except ARMv6M, normalises to ARMv6. 752 else if (Arch.startswith("armv6") && !Arch.endswith("6m")) 753 Arch = Arch.substr(0, 5); 754 // ARMv7A normalises to ARMv7. 755 else if (Arch.endswith("v7a")) 756 Arch = Arch.substr(0, 5); 757 return Arch.data(); 758} 759 760StringRef MachO::getMachOArchName(const ArgList &Args) const { 761 switch (getTriple().getArch()) { 762 default: 763 return getDefaultUniversalArchName(); 764 765 case llvm::Triple::aarch64: 766 return "arm64"; 767 768 case llvm::Triple::thumb: 769 case llvm::Triple::arm: 770 if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ)) 771 if (const char *Arch = ArmMachOArchName(A->getValue())) 772 return Arch; 773 774 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) 775 if (const char *Arch = ArmMachOArchNameCPU(A->getValue())) 776 return Arch; 777 778 return "arm"; 779 } 780} 781 782Darwin::~Darwin() {} 783 784MachO::~MachO() {} 785 786std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args, 787 types::ID InputType) const { 788 llvm::Triple Triple(ComputeLLVMTriple(Args, InputType)); 789 790 // If the target isn't initialized (e.g., an unknown Darwin platform, return 791 // the default triple). 792 if (!isTargetInitialized()) 793 return Triple.getTriple(); 794 795 SmallString<16> Str; 796 if (isTargetWatchOSBased()) 797 Str += "watchos"; 798 else if (isTargetTvOSBased()) 799 Str += "tvos"; 800 else if (isTargetIOSBased()) 801 Str += "ios"; 802 else 803 Str += "macosx"; 804 Str += getTargetVersion().getAsString(); 805 Triple.setOSName(Str); 806 807 return Triple.getTriple(); 808} 809 810Tool *MachO::getTool(Action::ActionClass AC) const { 811 switch (AC) { 812 case Action::LipoJobClass: 813 if (!Lipo) 814 Lipo.reset(new tools::darwin::Lipo(*this)); 815 return Lipo.get(); 816 case Action::DsymutilJobClass: 817 if (!Dsymutil) 818 Dsymutil.reset(new tools::darwin::Dsymutil(*this)); 819 return Dsymutil.get(); 820 case Action::VerifyDebugInfoJobClass: 821 if (!VerifyDebug) 822 VerifyDebug.reset(new tools::darwin::VerifyDebug(*this)); 823 return VerifyDebug.get(); 824 default: 825 return ToolChain::getTool(AC); 826 } 827} 828 829Tool *MachO::buildLinker() const { return new tools::darwin::Linker(*this); } 830 831Tool *MachO::buildAssembler() const { 832 return new tools::darwin::Assembler(*this); 833} 834 835DarwinClang::DarwinClang(const Driver &D, const llvm::Triple &Triple, 836 const ArgList &Args) 837 : Darwin(D, Triple, Args) {} 838 839void DarwinClang::addClangWarningOptions(ArgStringList &CC1Args) const { 840 // For modern targets, promote certain warnings to errors. 841 if (isTargetWatchOSBased() || getTriple().isArch64Bit()) { 842 // Always enable -Wdeprecated-objc-isa-usage and promote it 843 // to an error. 844 CC1Args.push_back("-Wdeprecated-objc-isa-usage"); 845 CC1Args.push_back("-Werror=deprecated-objc-isa-usage"); 846 847 // For iOS and watchOS, also error about implicit function declarations, 848 // as that can impact calling conventions. 849 if (!isTargetMacOS()) 850 CC1Args.push_back("-Werror=implicit-function-declaration"); 851 } 852} 853 854void DarwinClang::AddLinkARCArgs(const ArgList &Args, 855 ArgStringList &CmdArgs) const { 856 // Avoid linking compatibility stubs on i386 mac. 857 if (isTargetMacOS() && getArch() == llvm::Triple::x86) 858 return; 859 860 ObjCRuntime runtime = getDefaultObjCRuntime(/*nonfragile*/ true); 861 862 if ((runtime.hasNativeARC() || !isObjCAutoRefCount(Args)) && 863 runtime.hasSubscripting()) 864 return; 865 866 CmdArgs.push_back("-force_load"); 867 SmallString<128> P(getDriver().ClangExecutable); 868 llvm::sys::path::remove_filename(P); // 'clang' 869 llvm::sys::path::remove_filename(P); // 'bin' 870 llvm::sys::path::append(P, "lib", "arc", "libarclite_"); 871 // Mash in the platform. 872 if (isTargetWatchOSSimulator()) 873 P += "watchsimulator"; 874 else if (isTargetWatchOS()) 875 P += "watchos"; 876 else if (isTargetTvOSSimulator()) 877 P += "appletvsimulator"; 878 else if (isTargetTvOS()) 879 P += "appletvos"; 880 else if (isTargetIOSSimulator()) 881 P += "iphonesimulator"; 882 else if (isTargetIPhoneOS()) 883 P += "iphoneos"; 884 else 885 P += "macosx"; 886 P += ".a"; 887 888 CmdArgs.push_back(Args.MakeArgString(P)); 889} 890 891unsigned DarwinClang::GetDefaultDwarfVersion() const { 892 // Default to use DWARF 2 on OS X 10.10 / iOS 8 and lower. 893 if ((isTargetMacOS() && isMacosxVersionLT(10, 11)) || 894 (isTargetIOSBased() && isIPhoneOSVersionLT(9))) 895 return 2; 896 return 4; 897} 898 899void MachO::AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs, 900 StringRef DarwinLibName, bool AlwaysLink, 901 bool IsEmbedded, bool AddRPath) const { 902 SmallString<128> Dir(getDriver().ResourceDir); 903 llvm::sys::path::append(Dir, "lib", IsEmbedded ? "macho_embedded" : "darwin"); 904 905 SmallString<128> P(Dir); 906 llvm::sys::path::append(P, DarwinLibName); 907 908 // For now, allow missing resource libraries to support developers who may 909 // not have compiler-rt checked out or integrated into their build (unless 910 // we explicitly force linking with this library). 911 if (AlwaysLink || getVFS().exists(P)) 912 CmdArgs.push_back(Args.MakeArgString(P)); 913 914 // Adding the rpaths might negatively interact when other rpaths are involved, 915 // so we should make sure we add the rpaths last, after all user-specified 916 // rpaths. This is currently true from this place, but we need to be 917 // careful if this function is ever called before user's rpaths are emitted. 918 if (AddRPath) { 919 assert(DarwinLibName.endswith(".dylib") && "must be a dynamic library"); 920 921 // Add @executable_path to rpath to support having the dylib copied with 922 // the executable. 923 CmdArgs.push_back("-rpath"); 924 CmdArgs.push_back("@executable_path"); 925 926 // Add the path to the resource dir to rpath to support using the dylib 927 // from the default location without copying. 928 CmdArgs.push_back("-rpath"); 929 CmdArgs.push_back(Args.MakeArgString(Dir)); 930 } 931} 932 933void MachO::AddFuzzerLinkArgs(const ArgList &Args, ArgStringList &CmdArgs) const { 934 935 // Go up one directory from Clang to find the libfuzzer archive file. 936 StringRef ParentDir = llvm::sys::path::parent_path(getDriver().InstalledDir); 937 SmallString<128> P(ParentDir); 938 llvm::sys::path::append(P, "lib", "libLLVMFuzzer.a"); 939 CmdArgs.push_back(Args.MakeArgString(P)); 940 941 // Libfuzzer is written in C++ and requires libcxx. 942 AddCXXStdlibLibArgs(Args, CmdArgs); 943} 944 945StringRef Darwin::getPlatformFamily() const { 946 switch (TargetPlatform) { 947 case DarwinPlatformKind::MacOS: 948 return "MacOSX"; 949 case DarwinPlatformKind::IPhoneOS: 950 case DarwinPlatformKind::IPhoneOSSimulator: 951 return "iPhone"; 952 case DarwinPlatformKind::TvOS: 953 case DarwinPlatformKind::TvOSSimulator: 954 return "AppleTV"; 955 case DarwinPlatformKind::WatchOS: 956 case DarwinPlatformKind::WatchOSSimulator: 957 return "Watch"; 958 } 959 llvm_unreachable("Unsupported platform"); 960} 961 962StringRef Darwin::getSDKName(StringRef isysroot) { 963 // Assume SDK has path: SOME_PATH/SDKs/PlatformXX.YY.sdk 964 llvm::sys::path::const_iterator SDKDir; 965 auto BeginSDK = llvm::sys::path::begin(isysroot); 966 auto EndSDK = llvm::sys::path::end(isysroot); 967 for (auto IT = BeginSDK; IT != EndSDK; ++IT) { 968 StringRef SDK = *IT; 969 if (SDK.endswith(".sdk")) 970 return SDK.slice(0, SDK.size() - 4); 971 } 972 return ""; 973} 974 975StringRef Darwin::getOSLibraryNameSuffix() const { 976 switch(TargetPlatform) { 977 case DarwinPlatformKind::MacOS: 978 return "osx"; 979 case DarwinPlatformKind::IPhoneOS: 980 return "ios"; 981 case DarwinPlatformKind::IPhoneOSSimulator: 982 return "iossim"; 983 case DarwinPlatformKind::TvOS: 984 return "tvos"; 985 case DarwinPlatformKind::TvOSSimulator: 986 return "tvossim"; 987 case DarwinPlatformKind::WatchOS: 988 return "watchos"; 989 case DarwinPlatformKind::WatchOSSimulator: 990 return "watchossim"; 991 } 992 llvm_unreachable("Unsupported platform"); 993} 994 995void Darwin::addProfileRTLibs(const ArgList &Args, 996 ArgStringList &CmdArgs) const { 997 if (!needsProfileRT(Args)) return; 998 999 AddLinkRuntimeLib(Args, CmdArgs, (Twine("libclang_rt.profile_") + 1000 getOSLibraryNameSuffix() + ".a").str(), 1001 /*AlwaysLink*/ true); 1002} 1003 1004void DarwinClang::AddLinkSanitizerLibArgs(const ArgList &Args, 1005 ArgStringList &CmdArgs, 1006 StringRef Sanitizer) const { 1007 AddLinkRuntimeLib( 1008 Args, CmdArgs, 1009 (Twine("libclang_rt.") + Sanitizer + "_" + 1010 getOSLibraryNameSuffix() + "_dynamic.dylib").str(), 1011 /*AlwaysLink*/ true, /*IsEmbedded*/ false, 1012 /*AddRPath*/ true); 1013} 1014 1015ToolChain::RuntimeLibType DarwinClang::GetRuntimeLibType( 1016 const ArgList &Args) const { 1017 if (Arg* A = Args.getLastArg(options::OPT_rtlib_EQ)) { 1018 StringRef Value = A->getValue(); 1019 if (Value != "compiler-rt") 1020 getDriver().Diag(clang::diag::err_drv_unsupported_rtlib_for_platform) 1021 << Value << "darwin"; 1022 } 1023 1024 return ToolChain::RLT_CompilerRT; 1025} 1026 1027void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args, 1028 ArgStringList &CmdArgs) const { 1029 // Call once to ensure diagnostic is printed if wrong value was specified 1030 GetRuntimeLibType(Args); 1031 1032 // Darwin doesn't support real static executables, don't link any runtime 1033 // libraries with -static. 1034 if (Args.hasArg(options::OPT_static) || 1035 Args.hasArg(options::OPT_fapple_kext) || 1036 Args.hasArg(options::OPT_mkernel)) 1037 return; 1038 1039 // Reject -static-libgcc for now, we can deal with this when and if someone 1040 // cares. This is useful in situations where someone wants to statically link 1041 // something like libstdc++, and needs its runtime support routines. 1042 if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) { 1043 getDriver().Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args); 1044 return; 1045 } 1046 1047 const SanitizerArgs &Sanitize = getSanitizerArgs(); 1048 if (Sanitize.needsAsanRt()) 1049 AddLinkSanitizerLibArgs(Args, CmdArgs, "asan"); 1050 if (Sanitize.needsLsanRt()) 1051 AddLinkSanitizerLibArgs(Args, CmdArgs, "lsan"); 1052 if (Sanitize.needsUbsanRt()) 1053 AddLinkSanitizerLibArgs(Args, CmdArgs, "ubsan"); 1054 if (Sanitize.needsTsanRt()) 1055 AddLinkSanitizerLibArgs(Args, CmdArgs, "tsan"); 1056 if (Sanitize.needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib)) 1057 AddFuzzerLinkArgs(Args, CmdArgs); 1058 if (Sanitize.needsStatsRt()) { 1059 StringRef OS = isTargetMacOS() ? "osx" : "iossim"; 1060 AddLinkRuntimeLib(Args, CmdArgs, 1061 (Twine("libclang_rt.stats_client_") + OS + ".a").str(), 1062 /*AlwaysLink=*/true); 1063 AddLinkSanitizerLibArgs(Args, CmdArgs, "stats"); 1064 } 1065 if (Sanitize.needsEsanRt()) 1066 AddLinkSanitizerLibArgs(Args, CmdArgs, "esan"); 1067 1068 // Otherwise link libSystem, then the dynamic runtime library, and finally any 1069 // target specific static runtime library. 1070 CmdArgs.push_back("-lSystem"); 1071 1072 // Select the dynamic runtime library and the target specific static library. 1073 if (isTargetWatchOSBased()) { 1074 // We currently always need a static runtime library for watchOS. 1075 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.watchos.a"); 1076 } else if (isTargetTvOSBased()) { 1077 // We currently always need a static runtime library for tvOS. 1078 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.tvos.a"); 1079 } else if (isTargetIOSBased()) { 1080 // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1, 1081 // it never went into the SDK. 1082 // Linking against libgcc_s.1 isn't needed for iOS 5.0+ 1083 if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator() && 1084 getTriple().getArch() != llvm::Triple::aarch64) 1085 CmdArgs.push_back("-lgcc_s.1"); 1086 1087 // We currently always need a static runtime library for iOS. 1088 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a"); 1089 } else { 1090 assert(isTargetMacOS() && "unexpected non MacOS platform"); 1091 // The dynamic runtime library was merged with libSystem for 10.6 and 1092 // beyond; only 10.4 and 10.5 need an additional runtime library. 1093 if (isMacosxVersionLT(10, 5)) 1094 CmdArgs.push_back("-lgcc_s.10.4"); 1095 else if (isMacosxVersionLT(10, 6)) 1096 CmdArgs.push_back("-lgcc_s.10.5"); 1097 1098 // Originally for OS X, we thought we would only need a static runtime 1099 // library when targeting 10.4, to provide versions of the static functions 1100 // which were omitted from 10.4.dylib. This led to the creation of the 10.4 1101 // builtins library. 1102 // 1103 // Unfortunately, that turned out to not be true, because Darwin system 1104 // headers can still use eprintf on i386, and it is not exported from 1105 // libSystem. Therefore, we still must provide a runtime library just for 1106 // the tiny tiny handful of projects that *might* use that symbol. 1107 // 1108 // Then over time, we figured out it was useful to add more things to the 1109 // runtime so we created libclang_rt.osx.a to provide new functions when 1110 // deploying to old OS builds, and for a long time we had both eprintf and 1111 // osx builtin libraries. Which just seems excessive. So with PR 28855, we 1112 // are removing the eprintf library and expecting eprintf to be provided by 1113 // the OS X builtins library. 1114 if (isMacosxVersionLT(10, 5)) 1115 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a"); 1116 else 1117 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a"); 1118 } 1119} 1120 1121/// Returns the most appropriate macOS target version for the current process. 1122/// 1123/// If the macOS SDK version is the same or earlier than the system version, 1124/// then the SDK version is returned. Otherwise the system version is returned. 1125static std::string getSystemOrSDKMacOSVersion(StringRef MacOSSDKVersion) { 1126 unsigned Major, Minor, Micro; 1127 llvm::Triple SystemTriple(llvm::sys::getProcessTriple()); 1128 if (!SystemTriple.isMacOSX()) 1129 return MacOSSDKVersion; 1130 SystemTriple.getMacOSXVersion(Major, Minor, Micro); 1131 VersionTuple SystemVersion(Major, Minor, Micro); 1132 bool HadExtra; 1133 if (!Driver::GetReleaseVersion(MacOSSDKVersion, Major, Minor, Micro, 1134 HadExtra)) 1135 return MacOSSDKVersion; 1136 VersionTuple SDKVersion(Major, Minor, Micro); 1137 if (SDKVersion > SystemVersion) 1138 return SystemVersion.getAsString(); 1139 return MacOSSDKVersion; 1140} 1141 1142void Darwin::AddDeploymentTarget(DerivedArgList &Args) const { 1143 const OptTable &Opts = getDriver().getOpts(); 1144 1145 // Support allowing the SDKROOT environment variable used by xcrun and other 1146 // Xcode tools to define the default sysroot, by making it the default for 1147 // isysroot. 1148 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) { 1149 // Warn if the path does not exist. 1150 if (!getVFS().exists(A->getValue())) 1151 getDriver().Diag(clang::diag::warn_missing_sysroot) << A->getValue(); 1152 } else { 1153 if (char *env = ::getenv("SDKROOT")) { 1154 // We only use this value as the default if it is an absolute path, 1155 // exists, and it is not the root path. 1156 if (llvm::sys::path::is_absolute(env) && getVFS().exists(env) && 1157 StringRef(env) != "/") { 1158 Args.append(Args.MakeSeparateArg( 1159 nullptr, Opts.getOption(options::OPT_isysroot), env)); 1160 } 1161 } 1162 } 1163 1164 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ); 1165 Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ, 1166 options::OPT_mios_simulator_version_min_EQ); 1167 Arg *TvOSVersion = 1168 Args.getLastArg(options::OPT_mtvos_version_min_EQ, 1169 options::OPT_mtvos_simulator_version_min_EQ); 1170 Arg *WatchOSVersion = 1171 Args.getLastArg(options::OPT_mwatchos_version_min_EQ, 1172 options::OPT_mwatchos_simulator_version_min_EQ); 1173 1174 unsigned Major, Minor, Micro; 1175 bool HadExtra; 1176 1177 // The iOS deployment target that is explicitly specified via a command line 1178 // option or an environment variable. 1179 std::string ExplicitIOSDeploymentTargetStr; 1180 1181 if (iOSVersion) 1182 ExplicitIOSDeploymentTargetStr = iOSVersion->getAsString(Args); 1183 1184 // Add a macro to differentiate between m(iphone|tv|watch)os-version-min=X.Y and 1185 // -m(iphone|tv|watch)simulator-version-min=X.Y. 1186 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ) || 1187 Args.hasArg(options::OPT_mtvos_simulator_version_min_EQ) || 1188 Args.hasArg(options::OPT_mwatchos_simulator_version_min_EQ)) 1189 Args.append(Args.MakeSeparateArg(nullptr, Opts.getOption(options::OPT_D), 1190 " __APPLE_EMBEDDED_SIMULATOR__=1")); 1191 1192 if (OSXVersion && (iOSVersion || TvOSVersion || WatchOSVersion)) { 1193 getDriver().Diag(diag::err_drv_argument_not_allowed_with) 1194 << OSXVersion->getAsString(Args) 1195 << (iOSVersion ? iOSVersion : 1196 TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args); 1197 iOSVersion = TvOSVersion = WatchOSVersion = nullptr; 1198 } else if (iOSVersion && (TvOSVersion || WatchOSVersion)) { 1199 getDriver().Diag(diag::err_drv_argument_not_allowed_with) 1200 << iOSVersion->getAsString(Args) 1201 << (TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args); 1202 TvOSVersion = WatchOSVersion = nullptr; 1203 } else if (TvOSVersion && WatchOSVersion) { 1204 getDriver().Diag(diag::err_drv_argument_not_allowed_with) 1205 << TvOSVersion->getAsString(Args) 1206 << WatchOSVersion->getAsString(Args); 1207 WatchOSVersion = nullptr; 1208 } else if (!OSXVersion && !iOSVersion && !TvOSVersion && !WatchOSVersion) { 1209 // If no deployment target was specified on the command line, check for 1210 // environment defines. 1211 std::string OSXTarget; 1212 std::string iOSTarget; 1213 std::string TvOSTarget; 1214 std::string WatchOSTarget; 1215 1216 if (char *env = ::getenv("MACOSX_DEPLOYMENT_TARGET")) 1217 OSXTarget = env; 1218 if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET")) 1219 iOSTarget = env; 1220 if (char *env = ::getenv("TVOS_DEPLOYMENT_TARGET")) 1221 TvOSTarget = env; 1222 if (char *env = ::getenv("WATCHOS_DEPLOYMENT_TARGET")) 1223 WatchOSTarget = env; 1224 1225 if (!iOSTarget.empty()) 1226 ExplicitIOSDeploymentTargetStr = 1227 std::string("IPHONEOS_DEPLOYMENT_TARGET=") + iOSTarget; 1228 1229 // If there is no command-line argument to specify the Target version and 1230 // no environment variable defined, see if we can set the default based 1231 // on -isysroot. 1232 if (OSXTarget.empty() && iOSTarget.empty() && WatchOSTarget.empty() && 1233 TvOSTarget.empty() && Args.hasArg(options::OPT_isysroot)) { 1234 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) { 1235 StringRef isysroot = A->getValue(); 1236 StringRef SDK = getSDKName(isysroot); 1237 if (SDK.size() > 0) { 1238 // Slice the version number out. 1239 // Version number is between the first and the last number. 1240 size_t StartVer = SDK.find_first_of("0123456789"); 1241 size_t EndVer = SDK.find_last_of("0123456789"); 1242 if (StartVer != StringRef::npos && EndVer > StartVer) { 1243 StringRef Version = SDK.slice(StartVer, EndVer + 1); 1244 if (SDK.startswith("iPhoneOS") || 1245 SDK.startswith("iPhoneSimulator")) 1246 iOSTarget = Version; 1247 else if (SDK.startswith("MacOSX")) 1248 OSXTarget = getSystemOrSDKMacOSVersion(Version); 1249 else if (SDK.startswith("WatchOS") || 1250 SDK.startswith("WatchSimulator")) 1251 WatchOSTarget = Version; 1252 else if (SDK.startswith("AppleTVOS") || 1253 SDK.startswith("AppleTVSimulator")) 1254 TvOSTarget = Version; 1255 } 1256 } 1257 } 1258 } 1259 1260 // If no OS targets have been specified, try to guess platform from -target 1261 // or arch name and compute the version from the triple. 1262 if (OSXTarget.empty() && iOSTarget.empty() && TvOSTarget.empty() && 1263 WatchOSTarget.empty()) { 1264 llvm::Triple::OSType OSTy = llvm::Triple::UnknownOS; 1265 1266 // Set the OSTy based on -target if -arch isn't present. 1267 if (Args.hasArg(options::OPT_target) && !Args.hasArg(options::OPT_arch)) { 1268 OSTy = getTriple().getOS(); 1269 } else { 1270 StringRef MachOArchName = getMachOArchName(Args); 1271 if (MachOArchName == "armv7" || MachOArchName == "armv7s" || 1272 MachOArchName == "arm64") 1273 OSTy = llvm::Triple::IOS; 1274 else if (MachOArchName == "armv7k") 1275 OSTy = llvm::Triple::WatchOS; 1276 else if (MachOArchName != "armv6m" && MachOArchName != "armv7m" && 1277 MachOArchName != "armv7em") 1278 OSTy = llvm::Triple::MacOSX; 1279 } 1280 1281 1282 if (OSTy != llvm::Triple::UnknownOS) { 1283 unsigned Major, Minor, Micro; 1284 std::string *OSTarget; 1285 1286 switch (OSTy) { 1287 case llvm::Triple::Darwin: 1288 case llvm::Triple::MacOSX: 1289 if (!getTriple().getMacOSXVersion(Major, Minor, Micro)) 1290 getDriver().Diag(diag::err_drv_invalid_darwin_version) 1291 << getTriple().getOSName(); 1292 OSTarget = &OSXTarget; 1293 break; 1294 case llvm::Triple::IOS: 1295 getTriple().getiOSVersion(Major, Minor, Micro); 1296 OSTarget = &iOSTarget; 1297 break; 1298 case llvm::Triple::TvOS: 1299 getTriple().getOSVersion(Major, Minor, Micro); 1300 OSTarget = &TvOSTarget; 1301 break; 1302 case llvm::Triple::WatchOS: 1303 getTriple().getWatchOSVersion(Major, Minor, Micro); 1304 OSTarget = &WatchOSTarget; 1305 break; 1306 default: 1307 llvm_unreachable("Unexpected OS type"); 1308 break; 1309 } 1310 1311 llvm::raw_string_ostream(*OSTarget) << Major << '.' << Minor << '.' 1312 << Micro; 1313 } 1314 } 1315 1316 // Do not allow conflicts with the watchOS target. 1317 if (!WatchOSTarget.empty() && (!iOSTarget.empty() || !TvOSTarget.empty())) { 1318 getDriver().Diag(diag::err_drv_conflicting_deployment_targets) 1319 << "WATCHOS_DEPLOYMENT_TARGET" 1320 << (!iOSTarget.empty() ? "IPHONEOS_DEPLOYMENT_TARGET" : 1321 "TVOS_DEPLOYMENT_TARGET"); 1322 } 1323 1324 // Do not allow conflicts with the tvOS target. 1325 if (!TvOSTarget.empty() && !iOSTarget.empty()) { 1326 getDriver().Diag(diag::err_drv_conflicting_deployment_targets) 1327 << "TVOS_DEPLOYMENT_TARGET" 1328 << "IPHONEOS_DEPLOYMENT_TARGET"; 1329 } 1330 1331 // Allow conflicts among OSX and iOS for historical reasons, but choose the 1332 // default platform. 1333 if (!OSXTarget.empty() && (!iOSTarget.empty() || 1334 !WatchOSTarget.empty() || 1335 !TvOSTarget.empty())) { 1336 if (getTriple().getArch() == llvm::Triple::arm || 1337 getTriple().getArch() == llvm::Triple::aarch64 || 1338 getTriple().getArch() == llvm::Triple::thumb) 1339 OSXTarget = ""; 1340 else 1341 iOSTarget = WatchOSTarget = TvOSTarget = ""; 1342 } 1343 1344 if (!OSXTarget.empty()) { 1345 const Option O = Opts.getOption(options::OPT_mmacosx_version_min_EQ); 1346 OSXVersion = Args.MakeJoinedArg(nullptr, O, OSXTarget); 1347 Args.append(OSXVersion); 1348 } else if (!iOSTarget.empty()) { 1349 const Option O = Opts.getOption(options::OPT_miphoneos_version_min_EQ); 1350 iOSVersion = Args.MakeJoinedArg(nullptr, O, iOSTarget); 1351 Args.append(iOSVersion); 1352 } else if (!TvOSTarget.empty()) { 1353 const Option O = Opts.getOption(options::OPT_mtvos_version_min_EQ); 1354 TvOSVersion = Args.MakeJoinedArg(nullptr, O, TvOSTarget); 1355 Args.append(TvOSVersion); 1356 } else if (!WatchOSTarget.empty()) { 1357 const Option O = Opts.getOption(options::OPT_mwatchos_version_min_EQ); 1358 WatchOSVersion = Args.MakeJoinedArg(nullptr, O, WatchOSTarget); 1359 Args.append(WatchOSVersion); 1360 } 1361 } 1362 1363 DarwinPlatformKind Platform; 1364 if (OSXVersion) 1365 Platform = MacOS; 1366 else if (iOSVersion) 1367 Platform = IPhoneOS; 1368 else if (TvOSVersion) 1369 Platform = TvOS; 1370 else if (WatchOSVersion) 1371 Platform = WatchOS; 1372 else 1373 llvm_unreachable("Unable to infer Darwin variant"); 1374 1375 // Set the tool chain target information. 1376 if (Platform == MacOS) { 1377 assert((!iOSVersion && !TvOSVersion && !WatchOSVersion) && 1378 "Unknown target platform!"); 1379 if (!Driver::GetReleaseVersion(OSXVersion->getValue(), Major, Minor, Micro, 1380 HadExtra) || 1381 HadExtra || Major != 10 || Minor >= 100 || Micro >= 100) 1382 getDriver().Diag(diag::err_drv_invalid_version_number) 1383 << OSXVersion->getAsString(Args); 1384 } else if (Platform == IPhoneOS) { 1385 assert(iOSVersion && "Unknown target platform!"); 1386 if (!Driver::GetReleaseVersion(iOSVersion->getValue(), Major, Minor, Micro, 1387 HadExtra) || 1388 HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100) 1389 getDriver().Diag(diag::err_drv_invalid_version_number) 1390 << iOSVersion->getAsString(Args); 1391 // For 32-bit targets, the deployment target for iOS has to be earlier than 1392 // iOS 11. 1393 if (getTriple().isArch32Bit() && Major >= 11) { 1394 // If the deployment target is explicitly specified, print a diagnostic. 1395 if (!ExplicitIOSDeploymentTargetStr.empty()) { 1396 getDriver().Diag(diag::warn_invalid_ios_deployment_target) 1397 << ExplicitIOSDeploymentTargetStr; 1398 // Otherwise, set it to 10.99.99. 1399 } else { 1400 Major = 10; 1401 Minor = 99; 1402 Micro = 99; 1403 } 1404 } 1405 } else if (Platform == TvOS) { 1406 if (!Driver::GetReleaseVersion(TvOSVersion->getValue(), Major, Minor, 1407 Micro, HadExtra) || HadExtra || 1408 Major >= 100 || Minor >= 100 || Micro >= 100) 1409 getDriver().Diag(diag::err_drv_invalid_version_number) 1410 << TvOSVersion->getAsString(Args); 1411 } else if (Platform == WatchOS) { 1412 if (!Driver::GetReleaseVersion(WatchOSVersion->getValue(), Major, Minor, 1413 Micro, HadExtra) || HadExtra || 1414 Major >= 10 || Minor >= 100 || Micro >= 100) 1415 getDriver().Diag(diag::err_drv_invalid_version_number) 1416 << WatchOSVersion->getAsString(Args); 1417 } else 1418 llvm_unreachable("unknown kind of Darwin platform"); 1419 1420 // Recognize iOS targets with an x86 architecture as the iOS simulator. 1421 if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 || 1422 getTriple().getArch() == llvm::Triple::x86_64)) 1423 Platform = IPhoneOSSimulator; 1424 if (TvOSVersion && (getTriple().getArch() == llvm::Triple::x86 || 1425 getTriple().getArch() == llvm::Triple::x86_64)) 1426 Platform = TvOSSimulator; 1427 if (WatchOSVersion && (getTriple().getArch() == llvm::Triple::x86 || 1428 getTriple().getArch() == llvm::Triple::x86_64)) 1429 Platform = WatchOSSimulator; 1430 1431 setTarget(Platform, Major, Minor, Micro); 1432 1433 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) { 1434 StringRef SDK = getSDKName(A->getValue()); 1435 if (SDK.size() > 0) { 1436 size_t StartVer = SDK.find_first_of("0123456789"); 1437 StringRef SDKName = SDK.slice(0, StartVer); 1438 if (!SDKName.startswith(getPlatformFamily())) 1439 getDriver().Diag(diag::warn_incompatible_sysroot) 1440 << SDKName << getPlatformFamily(); 1441 } 1442 } 1443} 1444 1445void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args, 1446 ArgStringList &CmdArgs) const { 1447 CXXStdlibType Type = GetCXXStdlibType(Args); 1448 1449 switch (Type) { 1450 case ToolChain::CST_Libcxx: 1451 CmdArgs.push_back("-lc++"); 1452 break; 1453 1454 case ToolChain::CST_Libstdcxx: 1455 // Unfortunately, -lstdc++ doesn't always exist in the standard search path; 1456 // it was previously found in the gcc lib dir. However, for all the Darwin 1457 // platforms we care about it was -lstdc++.6, so we search for that 1458 // explicitly if we can't see an obvious -lstdc++ candidate. 1459 1460 // Check in the sysroot first. 1461 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) { 1462 SmallString<128> P(A->getValue()); 1463 llvm::sys::path::append(P, "usr", "lib", "libstdc++.dylib"); 1464 1465 if (!getVFS().exists(P)) { 1466 llvm::sys::path::remove_filename(P); 1467 llvm::sys::path::append(P, "libstdc++.6.dylib"); 1468 if (getVFS().exists(P)) { 1469 CmdArgs.push_back(Args.MakeArgString(P)); 1470 return; 1471 } 1472 } 1473 } 1474 1475 // Otherwise, look in the root. 1476 // FIXME: This should be removed someday when we don't have to care about 1477 // 10.6 and earlier, where /usr/lib/libstdc++.dylib does not exist. 1478 if (!getVFS().exists("/usr/lib/libstdc++.dylib") && 1479 getVFS().exists("/usr/lib/libstdc++.6.dylib")) { 1480 CmdArgs.push_back("/usr/lib/libstdc++.6.dylib"); 1481 return; 1482 } 1483 1484 // Otherwise, let the linker search. 1485 CmdArgs.push_back("-lstdc++"); 1486 break; 1487 } 1488} 1489 1490void DarwinClang::AddCCKextLibArgs(const ArgList &Args, 1491 ArgStringList &CmdArgs) const { 1492 // For Darwin platforms, use the compiler-rt-based support library 1493 // instead of the gcc-provided one (which is also incidentally 1494 // only present in the gcc lib dir, which makes it hard to find). 1495 1496 SmallString<128> P(getDriver().ResourceDir); 1497 llvm::sys::path::append(P, "lib", "darwin"); 1498 1499 // Use the newer cc_kext for iOS ARM after 6.0. 1500 if (isTargetWatchOS()) { 1501 llvm::sys::path::append(P, "libclang_rt.cc_kext_watchos.a"); 1502 } else if (isTargetTvOS()) { 1503 llvm::sys::path::append(P, "libclang_rt.cc_kext_tvos.a"); 1504 } else if (isTargetIPhoneOS()) { 1505 llvm::sys::path::append(P, "libclang_rt.cc_kext_ios.a"); 1506 } else { 1507 llvm::sys::path::append(P, "libclang_rt.cc_kext.a"); 1508 } 1509 1510 // For now, allow missing resource libraries to support developers who may 1511 // not have compiler-rt checked out or integrated into their build. 1512 if (getVFS().exists(P)) 1513 CmdArgs.push_back(Args.MakeArgString(P)); 1514} 1515 1516DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args, 1517 StringRef BoundArch, 1518 Action::OffloadKind) const { 1519 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs()); 1520 const OptTable &Opts = getDriver().getOpts(); 1521 1522 // FIXME: We really want to get out of the tool chain level argument 1523 // translation business, as it makes the driver functionality much 1524 // more opaque. For now, we follow gcc closely solely for the 1525 // purpose of easily achieving feature parity & testability. Once we 1526 // have something that works, we should reevaluate each translation 1527 // and try to push it down into tool specific logic. 1528 1529 for (Arg *A : Args) { 1530 if (A->getOption().matches(options::OPT_Xarch__)) { 1531 // Skip this argument unless the architecture matches either the toolchain 1532 // triple arch, or the arch being bound. 1533 llvm::Triple::ArchType XarchArch = 1534 tools::darwin::getArchTypeForMachOArchName(A->getValue(0)); 1535 if (!(XarchArch == getArch() || 1536 (!BoundArch.empty() && 1537 XarchArch == 1538 tools::darwin::getArchTypeForMachOArchName(BoundArch)))) 1539 continue; 1540 1541 Arg *OriginalArg = A; 1542 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1)); 1543 unsigned Prev = Index; 1544 std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index)); 1545 1546 // If the argument parsing failed or more than one argument was 1547 // consumed, the -Xarch_ argument's parameter tried to consume 1548 // extra arguments. Emit an error and ignore. 1549 // 1550 // We also want to disallow any options which would alter the 1551 // driver behavior; that isn't going to work in our model. We 1552 // use isDriverOption() as an approximation, although things 1553 // like -O4 are going to slip through. 1554 if (!XarchArg || Index > Prev + 1) { 1555 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args) 1556 << A->getAsString(Args); 1557 continue; 1558 } else if (XarchArg->getOption().hasFlag(options::DriverOption)) { 1559 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver) 1560 << A->getAsString(Args); 1561 continue; 1562 } 1563 1564 XarchArg->setBaseArg(A); 1565 1566 A = XarchArg.release(); 1567 DAL->AddSynthesizedArg(A); 1568 1569 // Linker input arguments require custom handling. The problem is that we 1570 // have already constructed the phase actions, so we can not treat them as 1571 // "input arguments". 1572 if (A->getOption().hasFlag(options::LinkerInput)) { 1573 // Convert the argument into individual Zlinker_input_args. 1574 for (const char *Value : A->getValues()) { 1575 DAL->AddSeparateArg( 1576 OriginalArg, Opts.getOption(options::OPT_Zlinker_input), Value); 1577 } 1578 continue; 1579 } 1580 } 1581 1582 // Sob. These is strictly gcc compatible for the time being. Apple 1583 // gcc translates options twice, which means that self-expanding 1584 // options add duplicates. 1585 switch ((options::ID)A->getOption().getID()) { 1586 default: 1587 DAL->append(A); 1588 break; 1589 1590 case options::OPT_mkernel: 1591 case options::OPT_fapple_kext: 1592 DAL->append(A); 1593 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static)); 1594 break; 1595 1596 case options::OPT_dependency_file: 1597 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue()); 1598 break; 1599 1600 case options::OPT_gfull: 1601 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag)); 1602 DAL->AddFlagArg( 1603 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols)); 1604 break; 1605 1606 case options::OPT_gused: 1607 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag)); 1608 DAL->AddFlagArg( 1609 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols)); 1610 break; 1611 1612 case options::OPT_shared: 1613 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib)); 1614 break; 1615 1616 case options::OPT_fconstant_cfstrings: 1617 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings)); 1618 break; 1619 1620 case options::OPT_fno_constant_cfstrings: 1621 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings)); 1622 break; 1623 1624 case options::OPT_Wnonportable_cfstrings: 1625 DAL->AddFlagArg(A, 1626 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings)); 1627 break; 1628 1629 case options::OPT_Wno_nonportable_cfstrings: 1630 DAL->AddFlagArg( 1631 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings)); 1632 break; 1633 1634 case options::OPT_fpascal_strings: 1635 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings)); 1636 break; 1637 1638 case options::OPT_fno_pascal_strings: 1639 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings)); 1640 break; 1641 } 1642 } 1643 1644 if (getTriple().getArch() == llvm::Triple::x86 || 1645 getTriple().getArch() == llvm::Triple::x86_64) 1646 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ)) 1647 DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_mtune_EQ), 1648 "core2"); 1649 1650 // Add the arch options based on the particular spelling of -arch, to match 1651 // how the driver driver works. 1652 if (!BoundArch.empty()) { 1653 StringRef Name = BoundArch; 1654 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ); 1655 const Option MArch = Opts.getOption(clang::driver::options::OPT_march_EQ); 1656 1657 // This code must be kept in sync with LLVM's getArchTypeForDarwinArch, 1658 // which defines the list of which architectures we accept. 1659 if (Name == "ppc") 1660 ; 1661 else if (Name == "ppc601") 1662 DAL->AddJoinedArg(nullptr, MCpu, "601"); 1663 else if (Name == "ppc603") 1664 DAL->AddJoinedArg(nullptr, MCpu, "603"); 1665 else if (Name == "ppc604") 1666 DAL->AddJoinedArg(nullptr, MCpu, "604"); 1667 else if (Name == "ppc604e") 1668 DAL->AddJoinedArg(nullptr, MCpu, "604e"); 1669 else if (Name == "ppc750") 1670 DAL->AddJoinedArg(nullptr, MCpu, "750"); 1671 else if (Name == "ppc7400") 1672 DAL->AddJoinedArg(nullptr, MCpu, "7400"); 1673 else if (Name == "ppc7450") 1674 DAL->AddJoinedArg(nullptr, MCpu, "7450"); 1675 else if (Name == "ppc970") 1676 DAL->AddJoinedArg(nullptr, MCpu, "970"); 1677 1678 else if (Name == "ppc64" || Name == "ppc64le") 1679 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64)); 1680 1681 else if (Name == "i386") 1682 ; 1683 else if (Name == "i486") 1684 DAL->AddJoinedArg(nullptr, MArch, "i486"); 1685 else if (Name == "i586") 1686 DAL->AddJoinedArg(nullptr, MArch, "i586"); 1687 else if (Name == "i686") 1688 DAL->AddJoinedArg(nullptr, MArch, "i686"); 1689 else if (Name == "pentium") 1690 DAL->AddJoinedArg(nullptr, MArch, "pentium"); 1691 else if (Name == "pentium2") 1692 DAL->AddJoinedArg(nullptr, MArch, "pentium2"); 1693 else if (Name == "pentpro") 1694 DAL->AddJoinedArg(nullptr, MArch, "pentiumpro"); 1695 else if (Name == "pentIIm3") 1696 DAL->AddJoinedArg(nullptr, MArch, "pentium2"); 1697 1698 else if (Name == "x86_64") 1699 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64)); 1700 else if (Name == "x86_64h") { 1701 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64)); 1702 DAL->AddJoinedArg(nullptr, MArch, "x86_64h"); 1703 } 1704 1705 else if (Name == "arm") 1706 DAL->AddJoinedArg(nullptr, MArch, "armv4t"); 1707 else if (Name == "armv4t") 1708 DAL->AddJoinedArg(nullptr, MArch, "armv4t"); 1709 else if (Name == "armv5") 1710 DAL->AddJoinedArg(nullptr, MArch, "armv5tej"); 1711 else if (Name == "xscale") 1712 DAL->AddJoinedArg(nullptr, MArch, "xscale"); 1713 else if (Name == "armv6") 1714 DAL->AddJoinedArg(nullptr, MArch, "armv6k"); 1715 else if (Name == "armv6m") 1716 DAL->AddJoinedArg(nullptr, MArch, "armv6m"); 1717 else if (Name == "armv7") 1718 DAL->AddJoinedArg(nullptr, MArch, "armv7a"); 1719 else if (Name == "armv7em") 1720 DAL->AddJoinedArg(nullptr, MArch, "armv7em"); 1721 else if (Name == "armv7k") 1722 DAL->AddJoinedArg(nullptr, MArch, "armv7k"); 1723 else if (Name == "armv7m") 1724 DAL->AddJoinedArg(nullptr, MArch, "armv7m"); 1725 else if (Name == "armv7s") 1726 DAL->AddJoinedArg(nullptr, MArch, "armv7s"); 1727 } 1728 1729 return DAL; 1730} 1731 1732void MachO::AddLinkRuntimeLibArgs(const ArgList &Args, 1733 ArgStringList &CmdArgs) const { 1734 // Embedded targets are simple at the moment, not supporting sanitizers and 1735 // with different libraries for each member of the product { static, PIC } x 1736 // { hard-float, soft-float } 1737 llvm::SmallString<32> CompilerRT = StringRef("libclang_rt."); 1738 CompilerRT += 1739 (tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard) 1740 ? "hard" 1741 : "soft"; 1742 CompilerRT += Args.hasArg(options::OPT_fPIC) ? "_pic.a" : "_static.a"; 1743 1744 AddLinkRuntimeLib(Args, CmdArgs, CompilerRT, false, true); 1745} 1746 1747bool Darwin::isAlignedAllocationUnavailable() const { 1748 switch (TargetPlatform) { 1749 case MacOS: // Earlier than 10.13. 1750 return TargetVersion < VersionTuple(10U, 13U, 0U); 1751 case IPhoneOS: 1752 case IPhoneOSSimulator: 1753 case TvOS: 1754 case TvOSSimulator: // Earlier than 11.0. 1755 return TargetVersion < VersionTuple(11U, 0U, 0U); 1756 case WatchOS: 1757 case WatchOSSimulator: // Earlier than 4.0. 1758 return TargetVersion < VersionTuple(4U, 0U, 0U); 1759 } 1760 llvm_unreachable("Unsupported platform"); 1761} 1762 1763void Darwin::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, 1764 llvm::opt::ArgStringList &CC1Args, 1765 Action::OffloadKind DeviceOffloadKind) const { 1766 if (isAlignedAllocationUnavailable()) 1767 CC1Args.push_back("-faligned-alloc-unavailable"); 1768} 1769 1770DerivedArgList * 1771Darwin::TranslateArgs(const DerivedArgList &Args, StringRef BoundArch, 1772 Action::OffloadKind DeviceOffloadKind) const { 1773 // First get the generic Apple args, before moving onto Darwin-specific ones. 1774 DerivedArgList *DAL = 1775 MachO::TranslateArgs(Args, BoundArch, DeviceOffloadKind); 1776 const OptTable &Opts = getDriver().getOpts(); 1777 1778 // If no architecture is bound, none of the translations here are relevant. 1779 if (BoundArch.empty()) 1780 return DAL; 1781 1782 // Add an explicit version min argument for the deployment target. We do this 1783 // after argument translation because -Xarch_ arguments may add a version min 1784 // argument. 1785 AddDeploymentTarget(*DAL); 1786 1787 // For iOS 6, undo the translation to add -static for -mkernel/-fapple-kext. 1788 // FIXME: It would be far better to avoid inserting those -static arguments, 1789 // but we can't check the deployment target in the translation code until 1790 // it is set here. 1791 if (isTargetWatchOSBased() || 1792 (isTargetIOSBased() && !isIPhoneOSVersionLT(6, 0))) { 1793 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) { 1794 Arg *A = *it; 1795 ++it; 1796 if (A->getOption().getID() != options::OPT_mkernel && 1797 A->getOption().getID() != options::OPT_fapple_kext) 1798 continue; 1799 assert(it != ie && "unexpected argument translation"); 1800 A = *it; 1801 assert(A->getOption().getID() == options::OPT_static && 1802 "missing expected -static argument"); 1803 *it = nullptr; 1804 ++it; 1805 } 1806 } 1807 1808 if (!Args.getLastArg(options::OPT_stdlib_EQ) && 1809 GetCXXStdlibType(Args) == ToolChain::CST_Libcxx) 1810 DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_stdlib_EQ), 1811 "libc++"); 1812 1813 // Validate the C++ standard library choice. 1814 CXXStdlibType Type = GetCXXStdlibType(*DAL); 1815 if (Type == ToolChain::CST_Libcxx) { 1816 // Check whether the target provides libc++. 1817 StringRef where; 1818 1819 // Complain about targeting iOS < 5.0 in any way. 1820 if (isTargetIOSBased() && isIPhoneOSVersionLT(5, 0)) 1821 where = "iOS 5.0"; 1822 1823 if (where != StringRef()) { 1824 getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where; 1825 } 1826 } 1827 1828 auto Arch = tools::darwin::getArchTypeForMachOArchName(BoundArch); 1829 if ((Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)) { 1830 if (Args.hasFlag(options::OPT_fomit_frame_pointer, 1831 options::OPT_fno_omit_frame_pointer, false)) 1832 getDriver().Diag(clang::diag::warn_drv_unsupported_opt_for_target) 1833 << "-fomit-frame-pointer" << BoundArch; 1834 } 1835 1836 return DAL; 1837} 1838 1839bool MachO::IsUnwindTablesDefault(const ArgList &Args) const { 1840 // Unwind tables are not emitted if -fno-exceptions is supplied (except when 1841 // targeting x86_64). 1842 return getArch() == llvm::Triple::x86_64 || 1843 (!UseSjLjExceptions(Args) && 1844 Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions, 1845 true)); 1846} 1847 1848bool MachO::UseDwarfDebugFlags() const { 1849 if (const char *S = ::getenv("RC_DEBUG_OPTIONS")) 1850 return S[0] != '\0'; 1851 return false; 1852} 1853 1854bool Darwin::UseSjLjExceptions(const ArgList &Args) const { 1855 // Darwin uses SjLj exceptions on ARM. 1856 if (getTriple().getArch() != llvm::Triple::arm && 1857 getTriple().getArch() != llvm::Triple::thumb) 1858 return false; 1859 1860 // Only watchOS uses the new DWARF/Compact unwinding method. 1861 llvm::Triple Triple(ComputeLLVMTriple(Args)); 1862 return !Triple.isWatchABI(); 1863} 1864 1865bool Darwin::SupportsEmbeddedBitcode() const { 1866 assert(TargetInitialized && "Target not initialized!"); 1867 if (isTargetIPhoneOS() && isIPhoneOSVersionLT(6, 0)) 1868 return false; 1869 return true; 1870} 1871 1872bool MachO::isPICDefault() const { return true; } 1873 1874bool MachO::isPIEDefault() const { return false; } 1875 1876bool MachO::isPICDefaultForced() const { 1877 return (getArch() == llvm::Triple::x86_64 || 1878 getArch() == llvm::Triple::aarch64); 1879} 1880 1881bool MachO::SupportsProfiling() const { 1882 // Profiling instrumentation is only supported on x86. 1883 return getArch() == llvm::Triple::x86 || getArch() == llvm::Triple::x86_64; 1884} 1885 1886void Darwin::addMinVersionArgs(const ArgList &Args, 1887 ArgStringList &CmdArgs) const { 1888 VersionTuple TargetVersion = getTargetVersion(); 1889 1890 if (isTargetWatchOS()) 1891 CmdArgs.push_back("-watchos_version_min"); 1892 else if (isTargetWatchOSSimulator()) 1893 CmdArgs.push_back("-watchos_simulator_version_min"); 1894 else if (isTargetTvOS()) 1895 CmdArgs.push_back("-tvos_version_min"); 1896 else if (isTargetTvOSSimulator()) 1897 CmdArgs.push_back("-tvos_simulator_version_min"); 1898 else if (isTargetIOSSimulator()) 1899 CmdArgs.push_back("-ios_simulator_version_min"); 1900 else if (isTargetIOSBased()) 1901 CmdArgs.push_back("-iphoneos_version_min"); 1902 else { 1903 assert(isTargetMacOS() && "unexpected target"); 1904 CmdArgs.push_back("-macosx_version_min"); 1905 } 1906 1907 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString())); 1908} 1909 1910void Darwin::addStartObjectFileArgs(const ArgList &Args, 1911 ArgStringList &CmdArgs) const { 1912 // Derived from startfile spec. 1913 if (Args.hasArg(options::OPT_dynamiclib)) { 1914 // Derived from darwin_dylib1 spec. 1915 if (isTargetWatchOSBased()) { 1916 ; // watchOS does not need dylib1.o. 1917 } else if (isTargetIOSSimulator()) { 1918 ; // iOS simulator does not need dylib1.o. 1919 } else if (isTargetIPhoneOS()) { 1920 if (isIPhoneOSVersionLT(3, 1)) 1921 CmdArgs.push_back("-ldylib1.o"); 1922 } else { 1923 if (isMacosxVersionLT(10, 5)) 1924 CmdArgs.push_back("-ldylib1.o"); 1925 else if (isMacosxVersionLT(10, 6)) 1926 CmdArgs.push_back("-ldylib1.10.5.o"); 1927 } 1928 } else { 1929 if (Args.hasArg(options::OPT_bundle)) { 1930 if (!Args.hasArg(options::OPT_static)) { 1931 // Derived from darwin_bundle1 spec. 1932 if (isTargetWatchOSBased()) { 1933 ; // watchOS does not need bundle1.o. 1934 } else if (isTargetIOSSimulator()) { 1935 ; // iOS simulator does not need bundle1.o. 1936 } else if (isTargetIPhoneOS()) { 1937 if (isIPhoneOSVersionLT(3, 1)) 1938 CmdArgs.push_back("-lbundle1.o"); 1939 } else { 1940 if (isMacosxVersionLT(10, 6)) 1941 CmdArgs.push_back("-lbundle1.o"); 1942 } 1943 } 1944 } else { 1945 if (Args.hasArg(options::OPT_pg) && SupportsProfiling()) { 1946 if (Args.hasArg(options::OPT_static) || 1947 Args.hasArg(options::OPT_object) || 1948 Args.hasArg(options::OPT_preload)) { 1949 CmdArgs.push_back("-lgcrt0.o"); 1950 } else { 1951 CmdArgs.push_back("-lgcrt1.o"); 1952 1953 // darwin_crt2 spec is empty. 1954 } 1955 // By default on OS X 10.8 and later, we don't link with a crt1.o 1956 // file and the linker knows to use _main as the entry point. But, 1957 // when compiling with -pg, we need to link with the gcrt1.o file, 1958 // so pass the -no_new_main option to tell the linker to use the 1959 // "start" symbol as the entry point. 1960 if (isTargetMacOS() && !isMacosxVersionLT(10, 8)) 1961 CmdArgs.push_back("-no_new_main"); 1962 } else { 1963 if (Args.hasArg(options::OPT_static) || 1964 Args.hasArg(options::OPT_object) || 1965 Args.hasArg(options::OPT_preload)) { 1966 CmdArgs.push_back("-lcrt0.o"); 1967 } else { 1968 // Derived from darwin_crt1 spec. 1969 if (isTargetWatchOSBased()) { 1970 ; // watchOS does not need crt1.o. 1971 } else if (isTargetIOSSimulator()) { 1972 ; // iOS simulator does not need crt1.o. 1973 } else if (isTargetIPhoneOS()) { 1974 if (getArch() == llvm::Triple::aarch64) 1975 ; // iOS does not need any crt1 files for arm64 1976 else if (isIPhoneOSVersionLT(3, 1)) 1977 CmdArgs.push_back("-lcrt1.o"); 1978 else if (isIPhoneOSVersionLT(6, 0)) 1979 CmdArgs.push_back("-lcrt1.3.1.o"); 1980 } else { 1981 if (isMacosxVersionLT(10, 5)) 1982 CmdArgs.push_back("-lcrt1.o"); 1983 else if (isMacosxVersionLT(10, 6)) 1984 CmdArgs.push_back("-lcrt1.10.5.o"); 1985 else if (isMacosxVersionLT(10, 8)) 1986 CmdArgs.push_back("-lcrt1.10.6.o"); 1987 1988 // darwin_crt2 spec is empty. 1989 } 1990 } 1991 } 1992 } 1993 } 1994 1995 if (!isTargetIPhoneOS() && Args.hasArg(options::OPT_shared_libgcc) && 1996 !isTargetWatchOS() && 1997 isMacosxVersionLT(10, 5)) { 1998 const char *Str = Args.MakeArgString(GetFilePath("crt3.o")); 1999 CmdArgs.push_back(Str); 2000 } 2001} 2002 2003bool Darwin::SupportsObjCGC() const { return isTargetMacOS(); } 2004 2005void Darwin::CheckObjCARC() const { 2006 if (isTargetIOSBased() || isTargetWatchOSBased() || 2007 (isTargetMacOS() && !isMacosxVersionLT(10, 6))) 2008 return; 2009 getDriver().Diag(diag::err_arc_unsupported_on_toolchain); 2010} 2011 2012SanitizerMask Darwin::getSupportedSanitizers() const { 2013 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64; 2014 SanitizerMask Res = ToolChain::getSupportedSanitizers(); 2015 Res |= SanitizerKind::Address; 2016 Res |= SanitizerKind::Leak; 2017 Res |= SanitizerKind::Fuzzer; 2018 if (isTargetMacOS()) { 2019 if (!isMacosxVersionLT(10, 9)) 2020 Res |= SanitizerKind::Vptr; 2021 Res |= SanitizerKind::SafeStack; 2022 if (IsX86_64) 2023 Res |= SanitizerKind::Thread; 2024 } else if (isTargetIOSSimulator() || isTargetTvOSSimulator()) { 2025 if (IsX86_64) 2026 Res |= SanitizerKind::Thread; 2027 } 2028 return Res; 2029} 2030 2031void Darwin::printVerboseInfo(raw_ostream &OS) const { 2032 CudaInstallation.print(OS); 2033} 2034