[compiler-rt][builtins][WIP] Add _IsOSVersionAtLeast, to be used by ObjC's @available

[erik.pilkington]

Summary

This patch adds the function _IsOSVersionAtLeast, which uses of Objective-C's @available will compile into. This function uses the Core Foundation API to parse the SystemVersion.plist file, which contains the marketing OS version, which is used by @available, as recommended here: https://reviews.llvm.org/D27827.

The API that I used for this requires at least macOS 10.6/iOS 4.0. Is this far enough back? We could provide to a conservative mapping from darwin versions to marketing versions (as suggested by Alex Lorenz) if this is too new.

Inb4 this patch doesn't have a testcase! I can't figure out how to run the builtins tests, looks like they're not attached to the cmake check-all target, as mentioned in test/CMakeLists.txt:8, and the shell script at test/builtins/Unit/test errors out on me (it can't find the darwin_fat directory), and looks like it hasn't been touched since 2010. How are these tests run? Is there any place where this is documented?

I did test this on my own machine, and works as intended on iOS simulators and macOS.

This patch is part of a feature I proposed last summer:
http://lists.llvm.org/pipermail/cfe-dev/2016-July/049851.html

Thanks for taking a look!
Erik

[arphaman]

Thanks for taking your time to work on this!

We've discussed the best approach internally and came to the conclusion that Gestalt should be used to determine the version of the OS even though it's officially deprecated. I'm sorry if my previous comments in which I dismissed Gestalt made you do extra work, I wasn't aware of some nuances back then. Can you please rewrite this function to use Gestalt?

[erik.pilkington]

@arphaman: AFAIK Gestalt() is only present on macOS (https://developer.apple.com/reference/coreservices/1471624-gestalt?language=objc), so for iOS and the like we'll need to fall back to parsing the SystemVersion.plist file. Is there any reason to prefer special casing macOS to use Gestalt?

[arphaman]

You're right, sorry about the confusion :)
I guess the plist approach should be used on macOS as well then.

[arphaman]

We need to add a test for this function as well, can you try to create one in test/builtins/Unit?

lib/builtins/os_version_check.c

31 ↗

(On Diff #89027)

NIT: The function name can be lowercase

61 ↗

(On Diff #89027)

Please add a check that verifies that malloc succeeded.

81 ↗

(On Diff #89027)

Please add a check to see if this call fails.

94 ↗

(On Diff #89027)

The function should be renamed to match the new name emitted by clang.

[erik.pilkington]

This new patch addresses Alex's comments:

• Add more failure checks
• Rename _IsOSVersionAtLeast -> __isOSVersionAtLeast

Additionally:

• fall back to the function CFPropertyListCreateFromXMLData if CFPropertyListCreateWithData is unavailable.

@arphaman: As far as adding a test to test/builtins/Unit, I would like to but I don't know how these tests are run. I went through my trouble with it in the description above. Do you know how these tests are run?

Thanks for taking a look!

[erik.pilkington]

Just realized I did a if (!&CFLongFunctionName) when I meant to do a if (&CFLongFunctionName). Oops!

[arphaman]

In D30136#686141, @erik.pilkington wrote:

@arphaman: As far as adding a test to test/builtins/Unit, I would like to but I don't know how these tests are run. I went through my trouble with it in the description above. Do you know how these tests are run?

It looks like the builtins didn't have cmake test support, but I've worked out a way to add it. I've attached a diff with a sample test that you can use:

test_availability.diff0 BDownload

I tested it on macOS only, so I'm not sure if the code is 100% correct.

[arphaman]

I uploaded an empty diff by mistake, here's the test diff that I had in mind:

test_availability.diff4 KBDownload

[erik.pilkington]

This new patch incorporates Alex Lorenz's testing infrastructure, and uses it to write a testcase.

[arphaman]

LGTM. Can you please ensure that the modifications to the testing infrastructure won't cause failures on non-Darwin platforms (e.g. Linux) before committing?

[erik.pilkington]

@arphaman: Sure, works as intended on debian8 x86_64. Thanks for all your help here!

[arphaman]

Looks like it's failing to build compiler-rt for iOS: http://lab.llvm.org:8080/green/job/clang-stage1-configure-RA_build/31958/consoleFull . I'm investigating the issue.

compiler-rt/trunk/lib/builtins/CMakeLists.txt

set(GENERIC_SOURCES
   mulxc3.c
   negdf2.c
   negdi2.c
   negsf2.c
   negti2.c
   negvdi2.c
   negvsi2.c
   negvti2.c
+  os_version_check.c
   paritydi2.c
   paritysi2.c
   parityti2.c
   popcountdi2.c
   popcountsi2.c
   popcountti2.c
   powidf2.c
   powisf2.c

compiler-rt/trunk/lib/builtins/os_version_check.c

+/* ===-- os_version_check.c - OS version checking  -------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements the function __isOSVersionAtLeast, used by
+ * Objective-C's @available
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#ifdef __APPLE__
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <Dispatch/Dispatch.h>
+#include <TargetConditionals.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* These three variables hold the host's OS version. */
+static int32_t GlobalMajor, GlobalMinor, GlobalSubminor;
+static dispatch_once_t DispatchOnceCounter;
+
+/* Find and parse the SystemVersion.plist file. */
+static void parseSystemVersionPList(void *Unused) {
+  (void)Unused;
+
+  char *PListPath = "/System/Library/CoreServices/SystemVersion.plist";
+
+#if TARGET_OS_SIMULATOR
+  char *PListPathPrefix = getenv("IPHONE_SIMULATOR_ROOT");
+  if (!PListPathPrefix)
+    return;
+  char FullPath[strlen(PListPathPrefix) + strlen(PListPath) + 1];
+  strcpy(FullPath, PListPathPrefix);
+  strcat(FullPath, PListPath);
+  PListPath = FullPath;
+#endif
+  FILE *PropertyList = fopen(PListPath, "r");
+  if (!PropertyList)
+    return;
+
+  /* Dynamically allocated stuff. */
+  CFDictionaryRef PListRef = NULL;
+  CFDataRef FileContentsRef = NULL;
+  UInt8 *PListBuf = NULL;
+
+  fseek(PropertyList, 0, SEEK_END);
+  long PListFileSize = ftell(PropertyList);
+  if (PListFileSize < 0)
+    goto Fail;
+  rewind(PropertyList);
+
+  PListBuf = malloc((size_t)PListFileSize);
+  if (!PListBuf)
+    goto Fail;
+
+  size_t NumRead = fread(PListBuf, 1, (size_t)PListFileSize, PropertyList);
+  if (NumRead != (size_t)PListFileSize)
+    goto Fail;
+
+  /* Get the file buffer into CF's format. We pass in a null allocator here *
+   * because we free PListBuf ourselves */
+  FileContentsRef = CFDataCreateWithBytesNoCopy(
+      NULL, PListBuf, (CFIndex)NumRead, kCFAllocatorNull);
+  if (!FileContentsRef)
+    goto Fail;
+
+  if (&CFPropertyListCreateWithData)
+    PListRef = CFPropertyListCreateWithData(
+        NULL, FileContentsRef, kCFPropertyListImmutable, NULL, NULL);
+  else
+    PListRef = CFPropertyListCreateFromXMLData(NULL, FileContentsRef,
+                                               kCFPropertyListImmutable, NULL);
+  if (!PListRef)
+    goto Fail;
+
+  CFTypeRef OpaqueValue =
+      CFDictionaryGetValue(PListRef, CFSTR("ProductVersion"));
+  if (!OpaqueValue || CFGetTypeID(OpaqueValue) != CFStringGetTypeID())
+    goto Fail;
+
+  char VersionStr[32];
+  if (!CFStringGetCString((CFStringRef)OpaqueValue, VersionStr,
+                          sizeof(VersionStr), kCFStringEncodingUTF8))
+    goto Fail;
+  sscanf(VersionStr, "%d.%d.%d", &GlobalMajor, &GlobalMinor, &GlobalSubminor);
+
+Fail:
+  if (PListRef)
+    CFRelease(PListRef);
+  if (FileContentsRef)
+    CFRelease(FileContentsRef);
+  free(PListBuf);
+  fclose(PropertyList);
+}
+
+int32_t __isOSVersionAtLeast(int32_t Major, int32_t Minor, int32_t Subminor) {
+  /* Populate the global version variables, if they haven't already. */
+  dispatch_once_f(&DispatchOnceCounter, NULL, parseSystemVersionPList);
+
+  if (Major < GlobalMajor) return 1;
+  if (Major > GlobalMajor) return 0;
+  if (Minor < GlobalMinor) return 1;
+  if (Minor > GlobalMinor) return 0;
+  return Subminor <= GlobalSubminor;
+}
+
+#endif

compiler-rt/trunk/test/CMakeLists.txt

 # Needed for lit support
 include(AddLLVM)
 
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.common.configured.in
   ${CMAKE_CURRENT_BINARY_DIR}/lit.common.configured)
 
-# BlocksRuntime and builtins testsuites are not yet ported to lit.
+# BlocksRuntime (and most of builtins) testsuites are not yet ported to lit.
 # add_subdirectory(BlocksRuntime)
-# add_subdirectory(builtins)
 
 set(SANITIZER_COMMON_LIT_TEST_DEPS)
 if(COMPILER_RT_STANDALONE_BUILD)
   add_executable(FileCheck IMPORTED GLOBAL)
   set_property(TARGET FileCheck PROPERTY IMPORTED_LOCATION ${LLVM_TOOLS_BINARY_DIR}/FileCheck)
   list(APPEND SANITIZER_COMMON_LIT_TEST_DEPS FileCheck)
 endif()
 
if(NOT ANDROID)
   if(CMAKE_HOST_UNIX)
     list(APPEND SANITIZER_COMMON_LIT_TEST_DEPS SanitizerLintCheck)
   endif()
 endif()
 
 # Run sanitizer tests only if we're sure that clang would produce
 # working binaries.
 if(COMPILER_RT_CAN_EXECUTE_TESTS)
+  if(COMPILER_RT_BUILD_BUILTINS)
+    add_subdirectory(builtins)
+  endif()
   if(COMPILER_RT_HAS_ASAN)
     add_subdirectory(asan)
   endif()
   if(COMPILER_RT_HAS_DFSAN)
     add_subdirectory(dfsan)
   endif()
   if (COMPILER_RT_HAS_INTERCEPTION)
     add_subdirectory(interception)

compiler-rt/trunk/test/builtins/CMakeLists.txt

+set(BUILTINS_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+set(BUILTINS_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS} builtins)
+set(BUILTINS_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/TestCases)
+
+# Test cases.
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+  ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
+)
+
+add_lit_testsuite(check-builtins "Running the Builtins tests"
+  ${BUILTINS_TESTSUITES}
+  DEPENDS ${BUILTINS_TEST_DEPS})
+set_target_properties(check-builtins PROPERTIES FOLDER "Compiler-RT Misc")

compiler-rt/trunk/test/builtins/TestCases/Darwin/lit.local.cfg

+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if root.host_os not in ['Darwin']:
+  config.unsupported = True

compiler-rt/trunk/test/builtins/TestCases/Darwin/os_version_check_test.c

+// RUN: %clang %s -o %t -mmacosx-version-min=10.5 -framework CoreFoundation -DMAJOR=%macos_version_major -DMINOR=%macos_version_minor -DSUBMINOR=%macos_version_subminor
+// RUN: %run %t
+
+int __isOSVersionAtLeast(int Major, int Minor, int Subminor);
+
+int main() {
+  if (!__isOSVersionAtLeast(MAJOR, MINOR, SUBMINOR))
+    return 1;
+  if (__isOSVersionAtLeast(MAJOR, MINOR, SUBMINOR + 1))
+    return 1;
+  if (SUBMINOR && __isOSVersionAtLeast(MAJOR + 1, MINOR, SUBMINOR - 1))
+    return 1;
+  if (SUBMINOR && !__isOSVersionAtLeast(MAJOR, MINOR, SUBMINOR - 1))
+    return 1;
+  if (MAJOR && !__isOSVersionAtLeast(MAJOR - 1, MINOR + 1, SUBMINOR))
+    return 1;
+
+  return 0;
+}

compiler-rt/trunk/test/builtins/lit.cfg

+# -*- Python -*-
+
+import os
+
+# Setup config name.
+config.name = 'Builtins'
+
+# Setup source root.
+config.test_source_root = os.path.dirname(__file__)
+
+# Test suffixes.
+config.suffixes = ['.c', '.cc', '.cpp', '.m', '.mm']
+
+# Define %clang and %clangxx substitutions to use in test RUN lines.
+config.substitutions.append( ("%clang ", " " + config.clang + " ") )
+
+if config.host_os == 'Darwin':
+  config.substitutions.append( ("%macos_version_major", str(config.darwin_osx_version[0])) )
+  config.substitutions.append( ("%macos_version_minor", str(config.darwin_osx_version[1])) )
+  config.substitutions.append( ("%macos_version_subminor", str(config.darwin_osx_version[2])) )

compiler-rt/trunk/test/builtins/lit.site.cfg.in

+@LIT_SITE_CFG_IN_HEADER@
+
+# Load common config for all compiler-rt lit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
+
+# Load tool-specific config that would do the real work.
+lit_config.load_config(config, "@BUILTINS_LIT_SOURCE_DIR@/lit.cfg")

compiler-rt/trunk/test/lit.common.cfg

if config.can_symbolize:
   config.available_features.add('can-symbolize')
 
 lit.util.usePlatformSdkOnDarwin(config, lit_config)
 
 if config.host_os == 'Darwin':
   try:
     osx_version = subprocess.check_output(["sw_vers", "-productVersion"])
     osx_version = tuple(int(x) for x in osx_version.split('.'))
+    config.darwin_osx_version = osx_version
     if osx_version >= (10, 11):
       config.available_features.add('osx-autointerception')
       config.available_features.add('osx-ld64-live_support')
     else:
       # The ASAN initialization-bug.cc test should XFAIL on OS X systems
       # older than El Capitan. By marking the test as being unsupported with
       # this "feature", we can pass the test on newer OS X versions and other
       # platforms.