static std::pair<StringRef, clang::VersionTuple> getOSAndVersionForDiagnostics(const llvm::Triple &triple) { StringRef osName; unsigned major, minor, micro; if (triple.isMacOSX()) { // macOS triples represent their versions differently, so we have to use the // special accessor. triple.getMacOSXVersion(major, minor, micro); osName = swift::prettyPlatformString(PlatformKind::OSX); } else { triple.getOSVersion(major, minor, micro); if (triple.isWatchOS()) { osName = swift::prettyPlatformString(PlatformKind::watchOS); } else if (triple.isTvOS()) { assert(triple.isiOS() && "LLVM treats tvOS as a kind of iOS, so tvOS is checked first"); osName = swift::prettyPlatformString(PlatformKind::tvOS); } else if (triple.isiOS()) { osName = swift::prettyPlatformString(PlatformKind::iOS); } else { assert(!triple.isOSDarwin() && "unknown Apple OS"); // Fallback to the LLVM triple name. This isn't great (it won't be // capitalized or anything), but it's better than nothing. osName = triple.getOSName(); } } assert(!osName.empty()); clang::VersionTuple version; if (micro != 0) version = clang::VersionTuple(major, minor, micro); else version = clang::VersionTuple(major, minor); return {osName, version}; }
StringRef swift::getPlatformNameForTriple(const llvm::Triple &triple) { if (triple.isiOS()) { if (triple.isTvOS()) { if (tripleIsAppleTVSimulator(triple)) return "appletvsimulator"; return "appletvos"; } if (tripleIsiOSSimulator(triple)) return "iphonesimulator"; return "iphoneos"; } if (triple.isWatchOS()) { if (tripleIsWatchSimulator(triple)) return "watchsimulator"; return "watchos"; } if (triple.isAndroid()) { return "android"; } if (triple.isMacOSX()) return "macosx"; if (triple.isOSLinux()) return "linux"; if (triple.isOSFreeBSD()) return "freebsd"; return ""; }
SanitizerKind swift::parseSanitizerArgValues(const llvm::opt::Arg *A, const llvm::Triple &Triple, DiagnosticEngine &Diags) { SanitizerKind kind = SanitizerKind::None; // Find the sanitizer kind. SanitizerKind pKind = SanitizerKind::None; for (int i = 0, n = A->getNumValues(); i != n; ++i) { kind = llvm::StringSwitch<SanitizerKind>(A->getValue(i)) .Case("address", SanitizerKind::Address) .Case("thread", SanitizerKind::Thread) .Default(SanitizerKind::None); if (kind == SanitizerKind::None) { Diags.diagnose(SourceLoc(), diag::error_unsupported_option_argument, A->getOption().getPrefixedName(), A->getValue(i)); return kind; } // Currently, more than one sanitizer cannot be enabled at the same time. if (pKind != SanitizerKind::None && pKind != kind) { SmallString<128> pb; SmallString<128> b; Diags.diagnose(SourceLoc(), diag::error_argument_not_allowed_with, (A->getOption().getPrefixedName() + toStringRef(pKind)).toStringRef(pb), (A->getOption().getPrefixedName() + toStringRef(kind)).toStringRef(b)); } pKind = kind; } if (kind == SanitizerKind::None) return kind; // Check if the target is supported for this sanitizer. // None of the sanitizers work on Linux right now. if (!Triple.isOSDarwin()) { SmallString<128> b; Diags.diagnose(SourceLoc(), diag::error_unsupported_opt_for_target, (A->getOption().getPrefixedName() + toStringRef(kind)).toStringRef(b), Triple.getTriple()); } // Thread Sanitizer only works on OS X and the simulators. It's only supported // on 64 bit architectures. if (kind == SanitizerKind::Thread && (!(Triple.isMacOSX() || tripleIsAnySimulator(Triple)) || !Triple.isArch64Bit())) { SmallString<128> b; Diags.diagnose(SourceLoc(), diag::error_unsupported_opt_for_target, (A->getOption().getPrefixedName() + toStringRef(kind)).toStringRef(b), Triple.getTriple()); } return kind; }
static bool isTargetTooNew(const llvm::Triple &moduleTarget, const llvm::Triple &ctxTarget) { unsigned major, minor, micro; if (moduleTarget.isMacOSX()) { moduleTarget.getMacOSXVersion(major, minor, micro); return ctxTarget.isMacOSXVersionLT(major, minor, micro); } moduleTarget.getOSVersion(major, minor, micro); return ctxTarget.isOSVersionLT(major, minor, micro); }
/// Returns true if the compiler depends on features provided by the ObjC /// runtime that are not present on the deployment target indicated by /// \p triple. static bool wantsObjCRuntime(const llvm::Triple &triple) { assert((!triple.isTvOS() || triple.isiOS()) && "tvOS is considered a kind of iOS"); // When updating the versions listed here, please record the most recent // feature being depended on and when it was introduced: // // - The hook to override class_getImageName (macOS 10.14 and equivalent) if (triple.isiOS()) return triple.isOSVersionLT(12); if (triple.isMacOSX()) return triple.isMacOSXVersionLT(10, 14); if (triple.isWatchOS()) return triple.isOSVersionLT(5); llvm_unreachable("unknown Darwin OS"); }
/// Returns true if the compiler depends on features provided by the ObjC /// runtime that are not present on the deployment target indicated by /// \p triple. static bool wantsObjCRuntime(const llvm::Triple &triple) { assert((!triple.isTvOS() || triple.isiOS()) && "tvOS is considered a kind of iOS"); // When updating the versions listed here, please record the most recent // feature being depended on and when it was introduced: // // - Make assigning 'nil' to an NSMutableDictionary subscript delete the // entry, like it does for Swift.Dictionary, rather than trap. if (triple.isiOS()) return triple.isOSVersionLT(9); if (triple.isMacOSX()) return triple.isMacOSXVersionLT(10, 11); if (triple.isWatchOS()) return false; llvm_unreachable("unknown Darwin OS"); }
DarwinPlatformKind swift::getDarwinPlatformKind(const llvm::Triple &triple) { if (triple.isiOS()) { if (triple.isTvOS()) { if (tripleIsAppleTVSimulator(triple)) return DarwinPlatformKind::TvOSSimulator; return DarwinPlatformKind::TvOS; } if (tripleIsiOSSimulator(triple)) return DarwinPlatformKind::IPhoneOSSimulator; return DarwinPlatformKind::IPhoneOS; } if (triple.isWatchOS()) { if (tripleIsWatchSimulator(triple)) return DarwinPlatformKind::WatchOSSimulator; return DarwinPlatformKind::WatchOS; } if (triple.isMacOSX()) return DarwinPlatformKind::MacOS; llvm_unreachable("Unsupported Darwin platform"); }
void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts, const llvm::Triple &Triple, StringRef &PlatformName, VersionTuple &PlatformMinVersion) { Builder.defineMacro("__APPLE_CC__", "6000"); Builder.defineMacro("__APPLE__"); Builder.defineMacro("__STDC_NO_THREADS__"); Builder.defineMacro("OBJC_NEW_PROPERTIES"); // AddressSanitizer doesn't play well with source fortification, which is on // by default on Darwin. if (Opts.Sanitize.has(SanitizerKind::Address)) Builder.defineMacro("_FORTIFY_SOURCE", "0"); // Darwin defines __weak, __strong, and __unsafe_unretained even in C mode. if (!Opts.ObjC) { // __weak is always defined, for use in blocks and with objc pointers. Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))"); Builder.defineMacro("__strong", ""); Builder.defineMacro("__unsafe_unretained", ""); } if (Opts.Static) Builder.defineMacro("__STATIC__"); else Builder.defineMacro("__DYNAMIC__"); if (Opts.POSIXThreads) Builder.defineMacro("_REENTRANT"); // Get the platform type and version number from the triple. unsigned Maj, Min, Rev; if (Triple.isMacOSX()) { Triple.getMacOSXVersion(Maj, Min, Rev); PlatformName = "macos"; } else { Triple.getOSVersion(Maj, Min, Rev); PlatformName = llvm::Triple::getOSTypeName(Triple.getOS()); } // If -target arch-pc-win32-macho option specified, we're // generating code for Win32 ABI. No need to emit // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__. if (PlatformName == "win32") { PlatformMinVersion = VersionTuple(Maj, Min, Rev); return; } // Set the appropriate OS version define. if (Triple.isiOS()) { assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!"); char Str[7]; if (Maj < 10) { Str[0] = '0' + Maj; Str[1] = '0' + (Min / 10); Str[2] = '0' + (Min % 10); Str[3] = '0' + (Rev / 10); Str[4] = '0' + (Rev % 10); Str[5] = '\0'; } else { // Handle versions >= 10. Str[0] = '0' + (Maj / 10); Str[1] = '0' + (Maj % 10); Str[2] = '0' + (Min / 10); Str[3] = '0' + (Min % 10); Str[4] = '0' + (Rev / 10); Str[5] = '0' + (Rev % 10); Str[6] = '\0'; } if (Triple.isTvOS()) Builder.defineMacro("__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__", Str); else Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str); } else if (Triple.isWatchOS()) { assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!"); char Str[6]; Str[0] = '0' + Maj; Str[1] = '0' + (Min / 10); Str[2] = '0' + (Min % 10); Str[3] = '0' + (Rev / 10); Str[4] = '0' + (Rev % 10); Str[5] = '\0'; Builder.defineMacro("__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__", Str); } else if (Triple.isMacOSX()) { // Note that the Driver allows versions which aren't representable in the // define (because we only get a single digit for the minor and micro // revision numbers). So, we limit them to the maximum representable // version. assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!"); char Str[7]; if (Maj < 10 || (Maj == 10 && Min < 10)) { Str[0] = '0' + (Maj / 10); Str[1] = '0' + (Maj % 10); Str[2] = '0' + std::min(Min, 9U); Str[3] = '0' + std::min(Rev, 9U); Str[4] = '\0'; } else { // Handle versions > 10.9. Str[0] = '0' + (Maj / 10); Str[1] = '0' + (Maj % 10); Str[2] = '0' + (Min / 10); Str[3] = '0' + (Min % 10); Str[4] = '0' + (Rev / 10); Str[5] = '0' + (Rev % 10); Str[6] = '\0'; } Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str); } // Tell users about the kernel if there is one. if (Triple.isOSDarwin()) Builder.defineMacro("__MACH__"); PlatformMinVersion = VersionTuple(Maj, Min, Rev); }