---

yaml
---
r: 346699
b: refs/heads/master
c: 25b9421
h: refs/heads/master
i:
  346697: c50f030
  346695: 3eabf18

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: f29a23a918be9ec89697116b74070faabd963c15
+refs/heads/master: 25b9421d4396373356246df83c7a6b9b3cc5f87e
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/lib/AST/PlatformKind.cpp

@@ -56,35 +56,43 @@ Optional<PlatformKind> swift::platformFromString(StringRef Name) {
       .Default(Optional<PlatformKind>());
 }
 
-bool swift::isPlatformActive(PlatformKind Platform, LangOptions &LangOpts) {
+static bool isPlatformActiveForTarget(PlatformKind Platform,
+                                      const llvm::Triple &Target,
+                                      bool EnableAppExtensionRestrictions) {
   if (Platform == PlatformKind::none)
     return true;
 
   if (Platform == PlatformKind::OSXApplicationExtension ||
       Platform == PlatformKind::iOSApplicationExtension)
-    if (!LangOpts.EnableAppExtensionRestrictions)
+    if (!EnableAppExtensionRestrictions)
       return false;
 
   // FIXME: This is an awful way to get the current OS.
   switch (Platform) {
     case PlatformKind::OSX:
     case PlatformKind::OSXApplicationExtension:
-      return LangOpts.Target.isMacOSX();
+      return Target.isMacOSX();
     case PlatformKind::iOS:
     case PlatformKind::iOSApplicationExtension:
-      return LangOpts.Target.isiOS() && !LangOpts.Target.isTvOS();
+      return Target.isiOS() && !Target.isTvOS();
     case PlatformKind::tvOS:
     case PlatformKind::tvOSApplicationExtension:
-      return LangOpts.Target.isTvOS();
+      return Target.isTvOS();
     case PlatformKind::watchOS:
     case PlatformKind::watchOSApplicationExtension:
-      return LangOpts.Target.isWatchOS();
+      return Target.isWatchOS();
     case PlatformKind::none:
       llvm_unreachable("handled above");
   }
   llvm_unreachable("bad PlatformKind");
 }
 
+bool swift::isPlatformActive(PlatformKind Platform, LangOptions &LangOpts) {
+  llvm::Triple TT = LangOpts.Target;
+  return isPlatformActiveForTarget(Platform, TT,
+                                   LangOpts.EnableAppExtensionRestrictions);
+}
+
 PlatformKind swift::targetPlatform(LangOptions &LangOpts) {
   if (LangOpts.Target.isMacOSX()) {
     return (LangOpts.EnableAppExtensionRestrictions

trunk/lib/SILGen/SILGenDecl.cpp

@@ -1194,25 +1194,38 @@ void SILGenFunction::visitVarDecl(VarDecl *D) {
   // We handle emitting the variable storage when we see the pattern binding.
 }
 
-/// Emit a check that returns 1 if the running OS version is in
-/// the specified version range and 0 otherwise. The returned SILValue
-/// (which has type Builtin.Int1) represents the result of this check.
-SILValue SILGenFunction::emitOSVersionRangeCheck(SILLocation loc,
-                                                 const VersionRange &range) {
-  // Emit constants for the checked version range.
-  llvm::VersionTuple Vers = range.getLowerEndpoint();
+/// Emit literals for the major, minor, and subminor components of the version
+/// and return a tuple of SILValues for them.
+static std::tuple<SILValue, SILValue, SILValue>
+emitVersionLiterals(SILLocation loc, SILGenBuilder &B, ASTContext &ctx,
+                    llvm::VersionTuple Vers) {
   unsigned major = Vers.getMajor();
   unsigned minor =
       (Vers.getMinor().hasValue() ? Vers.getMinor().getValue() : 0);
   unsigned subminor =
       (Vers.getSubminor().hasValue() ? Vers.getSubminor().getValue() : 0);
 
-  SILType wordType = SILType::getBuiltinWordType(getASTContext());
+  SILType wordType = SILType::getBuiltinWordType(ctx);
 
   SILValue majorValue = B.createIntegerLiteral(loc, wordType, major);
   SILValue minorValue = B.createIntegerLiteral(loc, wordType, minor);
   SILValue subminorValue = B.createIntegerLiteral(loc, wordType, subminor);
 
+  return std::make_tuple(majorValue, minorValue, subminorValue);
+}
+
+/// Emit a check that returns 1 if the running OS version is in
+/// the specified version range and 0 otherwise. The returned SILValue
+/// (which has type Builtin.Int1) represents the result of this check.
+SILValue SILGenFunction::emitOSVersionRangeCheck(SILLocation loc,
+                                                 const VersionRange &range) {
+  // Emit constants for the checked version range.
+  SILValue majorValue;
+  SILValue minorValue;
+  SILValue subminorValue;
+  std::tie(majorValue, minorValue, subminorValue) =
+      emitVersionLiterals(loc, B, getASTContext(), range.getLowerEndpoint());
+
   // Emit call to _stdlib_isOSVersionAtLeast(major, minor, patch)
   FuncDecl *versionQueryDecl =
       getASTContext().getIsOSVersionAtLeastDecl();