From 293b090ae7c9988be650e05bcf703df02cfea690 Mon Sep 17 00:00:00 2001 From: Akira Hatanaka Date: Fri, 17 Oct 2025 10:05:16 -0700 Subject: [PATCH] Infer visionOS availability from iOS availability Automatically infer and apply availability or unavailable attributes for visionOS based on the corresponding iOS availability of the same declaration using the version mapping information provided in SDKSettings.json. rdar://162148639 --- clang/CMakeLists.txt | 2 + clang/cmake/modules/AddDarwinPlatform.cmake | 23 ++++ clang/lib/Sema/CMakeLists.txt | 33 +++++ .../Sema/InferAvailabilityAttribute.cpp.in | 47 +++++++ ...bleAvailabilityFromFallbackPlatform.def.in | 108 ++++++++++++++++ clang/lib/Sema/SemaDeclAttr.cpp | 37 ++++++ .../Sema/Inputs/XROS.sdk/SDKSettings.json | 9 ++ .../xrOS/Sema/infer-ios-availability.c | 119 ++++++++++++++++++ ...le-from-missing-ios-availability-mapping.c | 14 +++ clang/test/lit.site.cfg.py.in | 5 + llvm/CMakeLists.txt | 4 + llvm/cmake/modules/LLVMConfig.cmake.in | 2 + llvm/test/lit.site.cfg.py.in | 5 + 13 files changed, 408 insertions(+) create mode 100644 clang/cmake/modules/AddDarwinPlatform.cmake create mode 100644 clang/lib/Sema/InferAvailabilityAttribute.cpp.in create mode 100644 clang/lib/Sema/PlatformTemplates/InferUnavailableAvailabilityFromFallbackPlatform.def.in create mode 100644 clang/test/PlatformSpecific/xrOS/Sema/Inputs/XROS.sdk/SDKSettings.json create mode 100644 clang/test/PlatformSpecific/xrOS/Sema/infer-ios-availability.c create mode 100644 clang/test/PlatformSpecific/xrOS/Sema/infer-unavailable-from-missing-ios-availability-mapping.c diff --git a/clang/CMakeLists.txt b/clang/CMakeLists.txt index c6496167d3828..75a2761c1fb56 100644 --- a/clang/CMakeLists.txt +++ b/clang/CMakeLists.txt @@ -364,6 +364,8 @@ endif() include(CMakeParseArguments) include(AddClang) +include(AddDarwinPlatform) +clang_add_additional_platform() set(CMAKE_INCLUDE_CURRENT_DIR ON) diff --git a/clang/cmake/modules/AddDarwinPlatform.cmake b/clang/cmake/modules/AddDarwinPlatform.cmake new file mode 100644 index 0000000000000..a00cede522e27 --- /dev/null +++ b/clang/cmake/modules/AddDarwinPlatform.cmake @@ -0,0 +1,23 @@ +# FIXME: How to generalize this to be driven by discovered SDKs? +function(clang_add_additional_platform) + # Add a platform. + set(name "xros") + set(CLANG_PLATFORM_${name}_PLATFORM_AVAILABILITY_NAME "xros" PARENT_SCOPE) + set(platformFallBack "iphoneos") + + if (NOT "${platformFallBack}" STREQUAL "") + set(fallbackTripleName "${platformFallBack}") + # FIXME: we need a generic platform -> triple mapping. + if ("${fallbackTripleName}" STREQUAL "iphoneos") + set(fallbackTripleName "ios") + endif() + + message(STATUS "Platform ${name} has fallback platform - ${fallbackTripleName}") + set(CLANG_PLATFORM_${name}_FALLBACK_PLATFORM_AVAILABILITY_NAME "${fallbackTripleName}" PARENT_SCOPE) + + # FIXME: This is a hack for xrOS, but should be in the SDKSettings too. + set(CLANG_PLATFORM_${name}_INFER_UNAVAILABLE 1 PARENT_SCOPE) + set(CLANG_PLATFORM_${name}_PLATFORM_TRIPLE_OS_VALUE "XROS" PARENT_SCOPE) + set(CLANG_PLATFORM_${name}_FALLBACK_PLATFORM_TRIPLE_OS_VALUE "IOS" PARENT_SCOPE) + endif() +endfunction() diff --git a/clang/lib/Sema/CMakeLists.txt b/clang/lib/Sema/CMakeLists.txt index 5d02f7e3737e6..db941d8c8678f 100644 --- a/clang/lib/Sema/CMakeLists.txt +++ b/clang/lib/Sema/CMakeLists.txt @@ -13,6 +13,38 @@ clang_tablegen(OpenCLBuiltins.inc -gen-clang-opencl-builtins TARGET ClangOpenCLBuiltinsImpl ) +# Configure additional platform-specific code that controls things like +# availability attributes. +set(TEMPLATE_INCLUDES_INFER_AVAILABILITY_ATTRIBUTE "") + +foreach(supported_platform ${LLVM_SUPPORTED_PLATFORMS}) + if (${CLANG_PLATFORM_${supported_platform}_INFER_UNAVAILABLE}) + # Generate code that infers availability(unavailable) attribute if a platform + # requires that. + set(output_file_name "InferUnavailableAvailabilityFromFallbackPlatform_${supported_platform}.def") + message(STATUS "Adding platform specific availability attribute code - ${output_file_name}") + + set(PLATFORM_TRIPLE_OS_VALUE + "${CLANG_PLATFORM_${supported_platform}_PLATFORM_TRIPLE_OS_VALUE}") + set(FALLBACK_PLATFORM_TRIPLE_OS_VALUE + "${CLANG_PLATFORM_${supported_platform}_FALLBACK_PLATFORM_TRIPLE_OS_VALUE}") + set(PLATFORM_AVAILABILITY_NAME + "${CLANG_PLATFORM_${supported_platform}_PLATFORM_AVAILABILITY_NAME}") + set(FALLBACK_PLATFORM_AVAILABILITY_NAME + "${CLANG_PLATFORM_${supported_platform}_FALLBACK_PLATFORM_AVAILABILITY_NAME}") + configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/PlatformTemplates/InferUnavailableAvailabilityFromFallbackPlatform.def.in + ${CMAKE_CURRENT_BINARY_DIR}/PlatformTemplates/${output_file_name} + ) + set(TEMPLATE_INCLUDES_INFER_AVAILABILITY_ATTRIBUTE "${TEMPLATE_INCLUDES_INFER_AVAILABILITY_ATTRIBUTE}\n#include \"PlatformTemplates/${output_file_name}\"") + endif() +endforeach() + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/InferAvailabilityAttribute.cpp.in + ${CMAKE_CURRENT_BINARY_DIR}/InferAvailabilityAttribute.cpp +) + add_clang_library(clangSema AnalysisBasedWarnings.cpp # TO_UPSTREAM(BoundsSafety) ON @@ -100,6 +132,7 @@ add_clang_library(clangSema SemaWasm.cpp SemaX86.cpp TypeLocBuilder.cpp + ${CMAKE_CURRENT_BINARY_DIR}/InferAvailabilityAttribute.cpp DEPENDS ClangOpenCLBuiltinsImpl diff --git a/clang/lib/Sema/InferAvailabilityAttribute.cpp.in b/clang/lib/Sema/InferAvailabilityAttribute.cpp.in new file mode 100644 index 0000000000000..5f96c4b9643be --- /dev/null +++ b/clang/lib/Sema/InferAvailabilityAttribute.cpp.in @@ -0,0 +1,47 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "clang/AST/ASTContext.h" +#include "clang/Basic/DarwinSDKInfo.h" +#include "clang/Basic/IdentifierTable.h" +#include "clang/Basic/LLVM.h" +#include "llvm/Support/VersionTuple.h" +#include "llvm/TargetParser/Triple.h" + +namespace clang { + +/// Returns true if the given availability attribute should be inferred, and +/// adjusts the value of the attribute as necessary to facilitate that. +bool shouldInferAvailabilityAttribute(const llvm::Triple &TT, + const DarwinSDKInfo *SDKInfo, + const ASTContext &Context, + IdentifierInfo *&II, + bool &IsUnavailable, + VersionTuple &Introduced, + VersionTuple &Deprecated, + VersionTuple &Obsolete) { + for (const auto &f : { + // function ptr promotion + +([] (const llvm::Triple &TT, + const DarwinSDKInfo *SDKInfo, + const ASTContext &Context, + IdentifierInfo *&II, + bool &IsUnavailable, + VersionTuple &Introduced, + VersionTuple &Deprecated, + VersionTuple &Obsolete) -> bool { return false; }), + @TEMPLATE_INCLUDES_INFER_AVAILABILITY_ATTRIBUTE@ + }) { + if (f(TT, SDKInfo, Context, II, IsUnavailable, Introduced, Deprecated, + Obsolete)) + return true; + } + return false; +} + +} // end namespace clang diff --git a/clang/lib/Sema/PlatformTemplates/InferUnavailableAvailabilityFromFallbackPlatform.def.in b/clang/lib/Sema/PlatformTemplates/InferUnavailableAvailabilityFromFallbackPlatform.def.in new file mode 100644 index 0000000000000..ee72e0181667f --- /dev/null +++ b/clang/lib/Sema/PlatformTemplates/InferUnavailableAvailabilityFromFallbackPlatform.def.in @@ -0,0 +1,108 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This platform-specific template implements inferral of +// __attribute__((availability(platform, unavailable))) from a base platform +// attribute __attribute__((availability(fallback platform, unavailable))). +// +// INPUTS: +// PLATFORM_TRIPLE_OS_VALUE - the name of the target OS enum in the Triple. +// FALLBACK_PLATFORM_TRIPLE_OS_VALUE - the name of the fallback target OS +// enum in the Triple. +// PLATFORM_AVAILABILITY_NAME - the name of availability platform. +// FALLBACK_PLATFORM_AVAILABILITY_NAME - the name of availability for the +// fallback platform. +// +//===----------------------------------------------------------------------===// + +// FIXME: This is now doing more than 'unavailable', the docs have to be updated. + +// x introduced := map(ios introduced, 1.0, None) +// None -> x unavailable +// -> x introduced + +// x deprecated := map(ios deprecated, 1.0, MaximumDeploymentVersion) +// None -> None +// -> x deprecated + +// x obsoleted := map(ios obsoleted, 1.0, MaximumDeploymentVersion) +// None -> x unavailable +// -> x obsoleted + +/// Returns true if the given availability attribute should be inferred. ++([] (const llvm::Triple &TT, + const DarwinSDKInfo *SDKInfo, + const ASTContext &Context, + IdentifierInfo *&II, + bool &IsUnavailable, + VersionTuple &Introduced, + VersionTuple &Deprecated, + VersionTuple &Obsolete) -> bool { + if (TT.getOS() != llvm::Triple::@PLATFORM_TRIPLE_OS_VALUE@) + return false; + IdentifierInfo *NewII = nullptr; + if (II->getName() == "@FALLBACK_PLATFORM_AVAILABILITY_NAME@") + NewII = &Context.Idents.get("@PLATFORM_AVAILABILITY_NAME@"); + else if (II->getName() == "@FALLBACK_PLATFORM_AVAILABILITY_NAME@_app_extension") + NewII = &Context.Idents.get("@PLATFORM_AVAILABILITY_NAME@_app_extension"); + if (!NewII) + return false; + II = NewII; + + auto MakeUnavailable = [&]() { + IsUnavailable = true; + // Reset introduced, deprecated, obsoleted. + Introduced = VersionTuple(); + Deprecated = VersionTuple(); + Obsolete = VersionTuple(); + }; + + if (!SDKInfo) { + MakeUnavailable(); + return true; + } + // Map from the fallback platform availability to the current platform + // availability. + const auto *Mapping = SDKInfo->getVersionMapping( + DarwinSDKInfo::OSEnvPair( + llvm::Triple::@FALLBACK_PLATFORM_TRIPLE_OS_VALUE@, + llvm::Triple::UnknownEnvironment, + llvm::Triple::@PLATFORM_TRIPLE_OS_VALUE@, + llvm::Triple::UnknownEnvironment)); + if (!Mapping) { + MakeUnavailable(); + return true; + } + + if (Introduced) { + auto NewIntroduced = Mapping->mapIntroducedAvailabilityVersion(Introduced); + if (!NewIntroduced) { + MakeUnavailable(); + return true; + } + Introduced = *NewIntroduced; + } + + if (Obsolete) { + auto NewObsolete = + Mapping->mapDeprecatedObsoletedAvailabilityVersion(Obsolete); + if (!NewObsolete) { + MakeUnavailable(); + return true; + } + Obsolete = *NewObsolete; + } + + if (Deprecated) { + auto NewDeprecated = + Mapping->mapDeprecatedObsoletedAvailabilityVersion(Deprecated); + Deprecated = NewDeprecated ? *NewDeprecated : VersionTuple(); + } + + return true; +}), diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp index 582d5f94c3404..b64285276caca 100644 --- a/clang/lib/Sema/SemaDeclAttr.cpp +++ b/clang/lib/Sema/SemaDeclAttr.cpp @@ -2266,6 +2266,17 @@ AvailabilityAttr *Sema::mergeAvailabilityAttr( return nullptr; } +namespace clang { + +/// Returns true if the given availability attribute should be inferred, and +/// adjusts the value of the attribute as necessary to facilitate that. +bool shouldInferAvailabilityAttribute( + const llvm::Triple &TT, const DarwinSDKInfo *SDKInfo, + const ASTContext &Context, IdentifierInfo *&II, bool &IsUnavailable, + VersionTuple &Introduced, VersionTuple &Deprecated, VersionTuple &Obsolete); + +} // end namespace clang + static void handleFeatureAvailabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) { if (S.getLangOpts().CPlusPlus) { @@ -2440,6 +2451,32 @@ static void handleAvailabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) { if (NewAttr) D->addAttr(NewAttr); + /* TO_UPSTREAM(XROS) ON */ + if (S.Context.getTargetInfo().getTriple().getOS() == llvm::Triple::XROS) { + // Infer availability attributes using platform-specific logic, driven by + // the SDKSettings if necessary. + IdentifierInfo *NewII = II; + bool NewIsUnavailable = IsUnavailable; + VersionTuple NewIntroduced = Introduced.Version; + VersionTuple NewDeprecated = Deprecated.Version; + VersionTuple NewObsoleted = Obsoleted.Version; + if (shouldInferAvailabilityAttribute(S.Context.getTargetInfo().getTriple(), + S.getDarwinSDKInfoForAvailabilityChecking(AL.getRange().getBegin(), "ios"), + S.Context, NewII, + NewIsUnavailable, NewIntroduced, + NewDeprecated, NewObsoleted)) { + AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr( + ND, AL, NewII, true /*Implicit*/, NewIntroduced, NewDeprecated, + NewObsoleted, NewIsUnavailable, Str, IsStrict, Replacement, + Sema::AMK_None, PriorityModifier + Sema::AP_InferredFromOtherPlatform, + IIEnvironment); + if (NewAttr) + D->addAttr(NewAttr); + } + } + + /* TO_UPSTREAM(XROS) OFF */ + // Transcribe "ios" to "watchos" (and add a new attribute) if the versioning // matches before the start of the watchOS platform. if (S.Context.getTargetInfo().getTriple().isWatchOS()) { diff --git a/clang/test/PlatformSpecific/xrOS/Sema/Inputs/XROS.sdk/SDKSettings.json b/clang/test/PlatformSpecific/xrOS/Sema/Inputs/XROS.sdk/SDKSettings.json new file mode 100644 index 0000000000000..cad7a55245751 --- /dev/null +++ b/clang/test/PlatformSpecific/xrOS/Sema/Inputs/XROS.sdk/SDKSettings.json @@ -0,0 +1,9 @@ +{ + "DefaultVariant": "xrOS", "DisplayName": "xrOS", + "Version": "1.0", + "CanonicalName": "xros1.0", + "MaximumDeploymentTarget": "1.0.99", + "VersionMap": { + "iOS_xrOS":{"15.0":"1.0"} + } +} diff --git a/clang/test/PlatformSpecific/xrOS/Sema/infer-ios-availability.c b/clang/test/PlatformSpecific/xrOS/Sema/infer-ios-availability.c new file mode 100644 index 0000000000000..7933f9d39bfad --- /dev/null +++ b/clang/test/PlatformSpecific/xrOS/Sema/infer-ios-availability.c @@ -0,0 +1,119 @@ +// REQUIRES: platform-xros + +// RUN: %clang_cc1 -triple arm64-apple-xros1 -verify=ios -isysroot %S/Inputs/XROS.sdk %s 2>&1 +// RUN: %clang_cc1 -triple arm64-apple-xros1 -fapplication-extension -verify=ios,ext -isysroot %S/Inputs/XROS.sdk %s 2>&1 + +// RUN: %clang_cc1 -triple arm64-apple-xros2 -DXROS2 -verify=ios -isysroot %S/Inputs/XROS.sdk %s 2>&1 + +__attribute__((availability(ios, unavailable))) +void ios_unavail(); // ios-note {{}} + +__attribute__((availability(ios_app_extension, unavailable))) +void ios_ext_unavail(); // ext-note {{}} + +void use() { + ios_unavail(); // ios-error {{'ios_unavail' is unavailable: not available on }} + ios_ext_unavail(); // ext-error {{'ios_ext_unavail' is unavailable: not available on }} +} + +__attribute__((availability(ios, introduced=10))) +void ios_introduced_10(); + +__attribute__((availability(ios_app_extension, introduced=10))) +void ios_ext_introduced_10(); + +__attribute__((availability(ios, introduced=15))) +void ios_introduced_15(); + +__attribute__((availability(ios_app_extension, introduced=15))) +void ios_ext_introduced_15(); + +__attribute__((availability(ios, introduced=16))) +void ios_introduced_16(); // ios-note {{}} + +__attribute__((availability(ios_app_extension, introduced=16))) +void ios_ext_introduced_16(); // ext-note {{}} + +void useIntroduced() { + // introduced iOS < 10 => introduced xrOS 1 + ios_introduced_10(); + ios_ext_introduced_10(); + // introduced iOS 15 => introduced xrOS 1 + ios_introduced_15(); + ios_ext_introduced_15(); + // introduced iOS 16 => xros unavailable (no mapping) + ios_introduced_16(); // ios-error {{is unavailable: not available on }} + ios_ext_introduced_16(); // ext-error {{is unavailable: not available on }} +} + +__attribute__((availability(ios, deprecated=10))) +void ios_deprecated_10(); // ios-note {{}} + +__attribute__((availability(ios_app_extension, deprecated=10))) +void ios_ext_deprecated_10(); // ext-note {{}} + +__attribute__((availability(ios, deprecated=15))) +void ios_deprecated_15(); // ios-note {{}} + +__attribute__((availability(ios_app_extension, deprecated=15))) +void ios_ext_deprecated_15(); // ext-note {{}} + +__attribute__((availability(ios, deprecated=16))) +void ios_deprecated_16(); +#ifdef XROS2 +// ios-note@-2 {{}} +#endif + +__attribute__((availability(ios_app_extension, deprecated=16))) +void ios_ext_deprecated_16(); + +void useDeprecated() { + // deprecated iOS < 10 => deprecated xrOS 1 + ios_deprecated_10(); // ios-warning {{is deprecated: first deprecated in}} + ios_ext_deprecated_10(); // ext-warning {{is deprecated: first deprecated in}} + // deprecated iOS 15 => deprecated xrOS 1 + ios_deprecated_15(); // ios-warning {{is deprecated: first deprecated in}} + ios_ext_deprecated_15(); // ext-warning {{is deprecated: first deprecated in}} + // deprecated iOS 16 => deprecated xrOS 1.0.99 + ios_deprecated_16(); +#ifdef XROS2 + // ios-warning@-2 {{is deprecated: first deprecated in}} +#endif + ios_ext_deprecated_16(); +} + +__attribute__((availability(ios, obsoleted=10))) +void ios_obsoleted_10(); // ios-note {{}} + +__attribute__((availability(ios_app_extension, obsoleted=10))) +void ios_ext_obsoleted_10(); // ext-note {{}} + +__attribute__((availability(ios, obsoleted=15))) +void ios_obsoleted_15(); // ios-note {{}} + +__attribute__((availability(ios_app_extension, obsoleted=15))) +void ios_ext_obsoleted_15(); // ext-note {{}} + +__attribute__((availability(ios, obsoleted=16))) +void ios_obsoleted_16(); +#ifdef XROS2 +// ios-note@-2 {{}} +#endif + +__attribute__((availability(ios_app_extension, obsoleted=16))) +void ios_ext_obsoleted_16(); + +void useObsoleted() { + // deprecated iOS < 10 => deprecated xrOS 1 + ios_obsoleted_10(); // ios-error {{is unavailable: obsoleted in}} + ios_ext_obsoleted_10(); // ext-error {{is unavailable: obsoleted in}} + // deprecated iOS 15 => deprecated xrOS 1 + ios_obsoleted_15(); // ios-error {{is unavailable: obsoleted in}} + ios_ext_obsoleted_15(); // ext-error {{is unavailable: obsoleted in}} + // obsoleted iOS 16 => obsoleted xrOS 1.0.99 + ios_obsoleted_16(); +#ifdef XROS2 + // ios-error@-2 {{is unavailable: obsoleted in}} +#endif + ios_ext_obsoleted_16(); +} diff --git a/clang/test/PlatformSpecific/xrOS/Sema/infer-unavailable-from-missing-ios-availability-mapping.c b/clang/test/PlatformSpecific/xrOS/Sema/infer-unavailable-from-missing-ios-availability-mapping.c new file mode 100644 index 0000000000000..a7b25bdb664b5 --- /dev/null +++ b/clang/test/PlatformSpecific/xrOS/Sema/infer-unavailable-from-missing-ios-availability-mapping.c @@ -0,0 +1,14 @@ +// REQUIRES: platform-xros + +// RUN: %clang_cc1 -triple arm64-apple-xros1 -verify=ios -DNOSDK %s 2>&1 +// RUN: %clang_cc1 -triple arm64-apple-xros1 -verify=ios -isysroot %S/Inputs/XROS.sdk %s 2>&1 + +#ifdef NOSDK +// ios-warning@+2 {{ios availability is ignored without a valid 'SDKSettings.json' in the SDK}} +#endif +__attribute__((availability(ios, introduced=17))) // note the version introduced has to be higher than the versions in SDKSettings +void ios_introduced_10(); // ios-note {{}} + +void useIntroduced() { + ios_introduced_10(); // ios-error {{is unavailable: not available on }} +} diff --git a/clang/test/lit.site.cfg.py.in b/clang/test/lit.site.cfg.py.in index e030342a2cf5c..be6f8e3b0eda6 100644 --- a/clang/test/lit.site.cfg.py.in +++ b/clang/test/lit.site.cfg.py.in @@ -50,6 +50,11 @@ config.substitutions.append(("%llvm-version-major", "@LLVM_VERSION_MAJOR@")) import lit.llvm lit.llvm.initialize(lit_config, config) +# Add additional features for each additional supported platform. +for platform in "@LLVM_SUPPORTED_PLATFORMS@".split(';'): + if platform: + config.available_features.add('platform-' + platform) + # Let the main config do the real work. lit_config.load_config( config, os.path.join(config.clang_src_dir, "test/lit.cfg.py")) diff --git a/llvm/CMakeLists.txt b/llvm/CMakeLists.txt index e9a64c9bc9e5a..06026a64e19f6 100644 --- a/llvm/CMakeLists.txt +++ b/llvm/CMakeLists.txt @@ -163,6 +163,10 @@ foreach(proj IN LISTS LLVM_ENABLE_RUNTIMES) endif() endforeach() +# This variable is referenced for generating custom platform support before it can be recognized +# in SDKSettings. It also helps drive fall-back availability inferences that is often used for platform bringup. +set(LLVM_SUPPORTED_PLATFORMS "xros" CACHE STRING "Additional supported platfroms") + # Set a shorthand option to enable the GPU build of the 'libc' project. option(LIBC_GPU_BUILD "Enable the 'libc' project targeting the GPU" OFF) if(LIBC_GPU_BUILD) diff --git a/llvm/cmake/modules/LLVMConfig.cmake.in b/llvm/cmake/modules/LLVMConfig.cmake.in index c49f10b9343ff..3fec1af5b5edd 100644 --- a/llvm/cmake/modules/LLVMConfig.cmake.in +++ b/llvm/cmake/modules/LLVMConfig.cmake.in @@ -140,6 +140,8 @@ set(LLVM_ENABLE_SHARED_LIBS @BUILD_SHARED_LIBS@) set(LLVM_DEFAULT_EXTERNAL_LIT "@LLVM_CONFIG_DEFAULT_EXTERNAL_LIT@") set(LLVM_LIT_ARGS "@LLVM_LIT_ARGS@") +set(LLVM_SUPPORTED_PLATFORMS "@LLVM_SUPPORTED_PLATFORMS@") + if(NOT TARGET LLVMSupport) @LLVM_CONFIG_INCLUDE_EXPORTS@ @llvm_config_include_buildtree_only_exports@ diff --git a/llvm/test/lit.site.cfg.py.in b/llvm/test/lit.site.cfg.py.in index 97c9f433c4cb0..4bd63db08a809 100644 --- a/llvm/test/lit.site.cfg.py.in +++ b/llvm/test/lit.site.cfg.py.in @@ -67,6 +67,11 @@ config.have_vc_rev = @LLVM_APPEND_VC_REV@ config.force_vc_rev = "@LLVM_FORCE_VC_REVISION@" config.has_logf128 = @LLVM_HAS_LOGF128@ +# Add additional features for each additional supported platform. +for platform in "@LLVM_SUPPORTED_PLATFORMS@".split(';'): + if platform: + config.available_features.add('platform-' + platform) + import lit.llvm lit.llvm.initialize(lit_config, config)