From 4c09e9a638b7ef16bc91de2f8202632b01d48e10 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 1bb73599970c1..3f2101a3903d6 100644 --- a/clang/CMakeLists.txt +++ b/clang/CMakeLists.txt @@ -370,6 +370,8 @@ if (APPLE AND NOT CMAKE_LINKER MATCHES ".*lld.*") endif() 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 20155d94900ee..d9770f87c8ed4 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 @@ -108,6 +140,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 ad380af03748c..17a8d0dbd9aa9 100644 --- a/clang/lib/Sema/SemaDeclAttr.cpp +++ b/clang/lib/Sema/SemaDeclAttr.cpp @@ -2420,6 +2420,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) { @@ -2601,6 +2612,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, + AvailabilityMergeKind::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..a41fbc947f007 --- /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 visionOS}} + ios_ext_unavail(); // ext-error {{'ios_ext_unavail' is unavailable: not available on visionOS}} +} + +__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 visionOS}} + ios_ext_introduced_16(); // ext-error {{is unavailable: not available on visionOS}} +} + +__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 visionOS 1.0}} + ios_ext_deprecated_10(); // ext-warning {{is deprecated: first deprecated in visionOS (App Extension) 1.0}} + // deprecated iOS 15 => deprecated xrOS 1 + ios_deprecated_15(); // ios-warning {{is deprecated: first deprecated in visionOS 1.0}} + ios_ext_deprecated_15(); // ext-warning {{is deprecated: first deprecated in visionOS (App Extension) 1.0}} + // deprecated iOS 16 => deprecated xrOS 1.0.99 + ios_deprecated_16(); +#ifdef XROS2 + // ios-warning@-2 {{is deprecated: first deprecated in visionOS 1.0.99}} +#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 visionOS 1.0}} + ios_ext_obsoleted_10(); // ext-error {{is unavailable: obsoleted in visionOS (App Extension) 1.0}} + // deprecated iOS 15 => deprecated xrOS 1 + ios_obsoleted_15(); // ios-error {{is unavailable: obsoleted in visionOS 1.0}} + ios_ext_obsoleted_15(); // ext-error {{is unavailable: obsoleted in visionOS (App Extension) 1.0}} + // obsoleted iOS 16 => obsoleted xrOS 1.0.99 + ios_obsoleted_16(); +#ifdef XROS2 + // ios-error@-2 {{is unavailable: obsoleted in visionOS 1.0.99}} +#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 badad9c3f264d..e37bf0840cef3 100644 --- a/clang/test/lit.site.cfg.py.in +++ b/clang/test/lit.site.cfg.py.in @@ -53,6 +53,11 @@ config.has_key_instructions = @LLVM_EXPERIMENTAL_KEY_INSTRUCTIONS@ 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 f3e878fe932b8..19c8bbff5cabe 100644 --- a/llvm/CMakeLists.txt +++ b/llvm/CMakeLists.txt @@ -224,6 +224,10 @@ if ("libclc" IN_LIST LLVM_ENABLE_PROJECTS) "https://libclc.llvm.org/ for building the runtimes.") endif() +# 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 c15b9576cd5d5..dfeac723ef9dd 100644 --- a/llvm/cmake/modules/LLVMConfig.cmake.in +++ b/llvm/cmake/modules/LLVMConfig.cmake.in @@ -142,6 +142,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 9c96254838b18..a6f31a65032b3 100644 --- a/llvm/test/lit.site.cfg.py.in +++ b/llvm/test/lit.site.cfg.py.in @@ -69,6 +69,11 @@ config.force_vc_rev = "@LLVM_FORCE_VC_REVISION@" config.has_logf128 = @LLVM_HAS_LOGF128@ config.has_key_instructions = @LLVM_EXPERIMENTAL_KEY_INSTRUCTIONS@ +# 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)