halide 19.0.0__cp39-cp39-macosx_11_0_x86_64.whl

halide/include/HalideRuntimeQurt.h

@@ -0,0 +1,32 @@
+#ifndef HALIDE_HALIDERUNTIMEQURT_H
+#define HALIDE_HALIDERUNTIMEQURT_H
+
+// Don't include HalideRuntime.h if the contents of it were already pasted into a generated header above this one
+#ifndef HALIDE_HALIDERUNTIME_H
+
+#include "HalideRuntime.h"
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** \file
+ *  Routines specific to the Halide QuRT runtime.
+ */
+
+/** Lock and unlock an HVX context.
+ *  A successful call to hvx_lock must be followed by a call to
+ *  hvx_unlock. */
+// @{
+extern int halide_qurt_hvx_lock(void *user_context);
+extern int halide_qurt_hvx_unlock(void *user_context);
+extern void halide_qurt_hvx_unlock_as_destructor(void *user_context, void * /*obj*/);
+// @}
+
+#ifdef __cplusplus
+}  // End extern "C"
+#endif
+
+#endif  // HALIDE_HALIDERUNTIMEQURT_H

halide/include/HalideRuntimeVulkan.h

@@ -0,0 +1,137 @@
+#ifndef HALIDE_HALIDERUNTIMEVULKAN_H
+#define HALIDE_HALIDERUNTIMEVULKAN_H
+
+// Don't include HalideRuntime.h if the contents of it were already pasted into a generated header above this one
+#ifndef HALIDE_HALIDERUNTIME_H
+
+#include "HalideRuntime.h"
+
+#endif
+/** \file
+ *  Routines specific to the Halide Vulkan runtime.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define HALIDE_RUNTIME_VULKAN
+
+// Guard against redefining handles if vulkan.h was included elsewhere
+#ifndef VK_DEFINE_HANDLE
+
+#define HALIDE_VULKAN_DEFINE_HANDLE(object) typedef struct object##_T *(object);
+
+#ifndef HALIDE_VULKAN_USE_64_BIT_PTR_DEFINES
+#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) || (defined(__riscv) && __riscv_xlen == 64)
+#define HALIDE_VULKAN_USE_64_BIT_PTR_DEFINES 1
+#else
+#define HALIDE_VULKAN_USE_64_BIT_PTR_DEFINES 0
+#endif
+#endif
+
+#ifndef HALIDE_VULKAN_DEFINE_NON_DISPATCHABLE_HANDLE
+#if (HALIDE_VULKAN_USE_64_BIT_PTR_DEFINES == 1)
+#define HALIDE_VULKAN_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *(object);
+#else
+#define HALIDE_VULKAN_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t(object);
+#endif
+#endif
+
+HALIDE_VULKAN_DEFINE_HANDLE(VkInstance)
+HALIDE_VULKAN_DEFINE_HANDLE(VkPhysicalDevice)
+HALIDE_VULKAN_DEFINE_HANDLE(VkDevice)
+HALIDE_VULKAN_DEFINE_HANDLE(VkQueue)
+HALIDE_VULKAN_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
+HALIDE_VULKAN_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT)
+
+#endif
+
+extern const struct halide_device_interface_t *halide_vulkan_device_interface();
+
+/** These are forward declared here to allow clients to override the
+ *  Halide Vulkan runtime. Do not call them. */
+// @{
+extern int halide_vulkan_initialize_kernels(void *user_context, void **state_ptr,
+                                            const char *src, int size);
+
+extern int halide_vulkan_run(void *user_context,
+                             void *state_ptr,
+                             const char *entry_name,
+                             int blocksX, int blocksY, int blocksZ,
+                             int threadsX, int threadsY, int threadsZ,
+                             int shared_mem_bytes,
+                             size_t arg_sizes[],
+                             void *args[],
+                             int8_t arg_is_buffer[]);
+
+extern void halide_vulkan_finalize_kernels(void *user_context, void *state_ptr);
+
+// @}
+
+// The default implementation of halide_acquire_vulkan_context uses
+// the global pointers above, and serializes access with a spin lock.
+// Overriding implementations of acquire/release must implement the
+// following behavior:
+
+// - halide_acquire_vulkan_context should always store a valid
+//   instance/device/queue in the corresponding out parameters,
+//   or return an error code.
+// - A call to halide_acquire_vulkan_context is followed by a matching
+//   call to halide_release_vulkan_context. halide_acquire_vulkan_context
+//   should block while a previous call (if any) has not yet been
+//   released via halide_release_vulkan_context.
+// - Parameters:
+//      allocator: an internal halide type handle used for allocating resources
+//      instance: the vulkan instance handle
+//      device: the vulkan device handle
+//      physical_device: the vulkan physical device handle
+//      queue: the vulkan queue handle
+//      queue_family_index: the index corresponding to the device queue properties for the device (as described by vkGetPhysicalDeviceQueueFamilyProperties)
+//      create: if set to true, attempt to create a new vulkan context, otherwise acquire the current one
+struct halide_vulkan_memory_allocator;
+extern int halide_vulkan_acquire_context(void *user_context,
+                                         struct halide_vulkan_memory_allocator **allocator,
+                                         VkInstance *instance,
+                                         VkDevice *device,
+                                         VkPhysicalDevice *physical_device,
+                                         VkQueue *queue,
+                                         uint32_t *queue_family_index,
+                                         VkDebugUtilsMessengerEXT *messenger,
+                                         bool create = true);
+
+extern int halide_vulkan_release_context(void *user_context,
+                                         VkInstance instance,
+                                         VkDevice device,
+                                         VkQueue queue,
+                                         VkDebugUtilsMessengerEXT messenger);
+// --
+
+// Override the default allocation callbacks (default uses Vulkan runtime implementation)
+extern void halide_vulkan_set_allocation_callbacks(const struct VkAllocationCallbacks *callbacks);
+
+// Access the current allocation callbacks
+// -- may return nullptr ... which indicates the default Vulkan runtime implementation is being used)
+extern const struct VkAllocationCallbacks *halide_vulkan_get_allocation_callbacks(void *user_context);
+
+// Access methods to assign/retrieve required layer names for the context
+extern void halide_vulkan_set_layer_names(const char *n);
+extern const char *halide_vulkan_get_layer_names(void *user_context);
+
+// Access methods to assign/retrieve required externsion names for the context
+extern void halide_vulkan_set_extension_names(const char *n);
+extern const char *halide_vulkan_get_extension_names(void *user_context);
+
+// Access methods to assign/retrieve required device type names for the context (either "cpu", "gpu" (any), "discrete-gpu" (only), "virtual-gpu" (sw))
+extern void halide_vulkan_set_device_type(const char *n);
+extern const char *halide_vulkan_get_device_type(void *user_context);
+
+// Access methods to assign/retrieve specific build options to the Vulkan runtime compiler
+extern void halide_vulkan_set_build_options(const char *n);
+extern const char *halide_vulkan_get_build_options(void *user_context);
+
+#ifdef __cplusplus
+}  // End extern "C"
+#endif
+
+#endif  // HALIDE_HALIDERUNTIMEVULKAN_H

halide/include/HalideRuntimeWebGPU.h

@@ -0,0 +1,44 @@
+#ifndef HALIDE_HALIDERUNTIMEWEBGPU_H
+#define HALIDE_HALIDERUNTIMEWEBGPU_H
+
+// Don't include HalideRuntime.h if the contents of it were already pasted into a generated header above this one
+#ifndef HALIDE_HALIDERUNTIME_H
+
+#include "HalideRuntime.h"
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** \file
+ *  Routines specific to the Halide WebGPU runtime.
+ */
+
+#define HALIDE_RUNTIME_WEBGPU
+
+extern const struct halide_device_interface_t *halide_webgpu_device_interface();
+
+/** These are forward declared here to allow clients to override the
+ *  Halide WebGPU runtime. Do not call them. */
+// @{
+extern int halide_webgpu_initialize_kernels(void *user_context, void **state_ptr,
+                                            const char *src, int size);
+extern int halide_webgpu_run(void *user_context,
+                             void *state_ptr,
+                             const char *entry_name,
+                             int blocksX, int blocksY, int blocksZ,
+                             int threadsX, int threadsY, int threadsZ,
+                             int shared_mem_bytes,
+                             halide_type_t arg_types[],
+                             void *args[],
+                             int8_t arg_is_buffer[]);
+extern void halide_webgpu_finalize_kernels(void *user_context, void *state_ptr);
+// @}
+
+#ifdef __cplusplus
+}  // End extern "C"
+#endif
+
+#endif  // HALIDE_HALIDERUNTIMEWEBGPU_H

halide/lib/cmake/Halide/FindHalide_LLVM.cmake

@@ -0,0 +1,152 @@
+# This file wraps the upstream package config modules for LLVM, Clang, and LLD
+# to fix pathological issues in their implementations. It creates imported targets
+# that wrap the key features needed by Halide.
+
+set(REASON_FAILURE_MESSAGE "")
+
+# Fallback configurations for weirdly built LLVMs
+set(CMAKE_MAP_IMPORTED_CONFIG_MINSIZEREL MinSizeRel Release RelWithDebInfo "")
+set(CMAKE_MAP_IMPORTED_CONFIG_RELWITHDEBINFO RelWithDebInfo Release MinSizeRel "")
+set(CMAKE_MAP_IMPORTED_CONFIG_RELEASE Release MinSizeRel RelWithDebInfo "")
+
+find_package(LLVM ${PACKAGE_FIND_VERSION} CONFIG)
+
+set(Halide_LLVM_VERSION "${LLVM_PACKAGE_VERSION}")
+
+# TODO: deprecated in Halide 19.0.0, remove in Halide 20.0.0
+if (NOT DEFINED Halide_LLVM_SHARED_LIBS AND DEFINED Halide_SHARED_LLVM)
+    set(Halide_LLVM_SHARED_LIBS "${Halide_SHARED_LLVM}")
+    message(DEPRECATION
+            "Halide_SHARED_LLVM has been renamed to Halide_LLVM_SHARED_LIBS.")
+endif ()
+
+if (NOT DEFINED Halide_LLVM_SHARED_LIBS)
+    # Normally, we don't like making decisions for our users. However,
+    # this avoids an incompatible scenario that is checked below. So
+    # if we didn't do this, the package would fail to be found and
+    # the user would have to either rebuild LLVM or flip this value.
+    if (LLVM_FOUND AND "WebAssembly" IN_LIST LLVM_TARGETS_TO_BUILD AND LLVM_LINK_LLVM_DYLIB)
+        set(Halide_LLVM_SHARED_LIBS YES)
+    else ()
+        set(Halide_LLVM_SHARED_LIBS NO)
+    endif ()
+endif ()
+
+option(Halide_LLVM_SHARED_LIBS "Enable to link to shared libLLVM" "${Halide_LLVM_SHARED_LIBS}")
+
+if (LLVM_FOUND)
+    find_package(Clang HINTS "${LLVM_INSTALL_PREFIX}" "${LLVM_DIR}/../clang" "${LLVM_DIR}/../lib/cmake/clang")
+
+    foreach (comp IN LISTS LLVM_TARGETS_TO_BUILD)
+        if (comp STREQUAL "WebAssembly")
+            set(Halide_LLVM_${comp}_FOUND 0)
+
+            find_package(LLD HINTS "${LLVM_INSTALL_PREFIX}" "${LLVM_DIR}/../lld" "${LLVM_DIR}/../lib/cmake/lld")
+            if (NOT LLD_FOUND)
+                string(APPEND REASON_FAILURE_MESSAGE
+                       "WebAssembly was not found because liblld is missing. "
+                       "Did you `apt install liblld-dev` or `brew install lld`?\n")
+                continue()
+            endif ()
+
+            # LLVM has a mis-feature that allows it to build and export both static and shared libraries at the same
+            # time, while inconsistently linking its own static libraries (for lldWasm and others) to the shared
+            # library. Ignoring this causes Halide to link to both the static AND the shared LLVM libs and it breaks at
+            # runtime. See: https://github.com/halide/Halide/issues/5471
+            if (LLVM_LINK_LLVM_DYLIB AND NOT Halide_LLVM_SHARED_LIBS)
+                string(APPEND REASON_FAILURE_MESSAGE
+                       "WebAssembly was not found because LLD required by was linked to shared LLVM "
+                       "(LLVM_LINK_LLVM_DYLIB=${LLVM_LINK_LLVM_DYLIB}) but static LLVM was requested "
+                       "(Halide_LLVM_SHARED_LIBS=${Halide_LLVM_SHARED_LIBS}).\n")
+                continue()
+            endif ()
+        endif ()
+
+        set(Halide_LLVM_${comp}_FOUND 1)
+    endforeach ()
+
+    set(Halide_LLVM_SHARED_LIBRARY "LLVM")
+    if (Halide_LLVM_SHARED_LIBS AND NOT TARGET "${Halide_LLVM_SHARED_LIBRARY}")
+        string(APPEND Halide_LLVM_SHARED_LIBRARY "-NOTFOUND")
+        string(APPEND REASON_FAILURE_MESSAGE
+               "Halide_LLVM_SHARED_LIBS=${Halide_LLVM_SHARED_LIBS} but the shared LLVM target does not exist.\n")
+    endif ()
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(
+    Halide_LLVM
+    REQUIRED_VARS LLVM_CONFIG Clang_CONFIG Halide_LLVM_SHARED_LIBRARY
+    VERSION_VAR Halide_LLVM_VERSION
+    REASON_FAILURE_MESSAGE "${REASON_FAILURE_MESSAGE}"
+    HANDLE_COMPONENTS
+    HANDLE_VERSION_RANGE
+    NAME_MISMATCHED
+)
+
+function(_Halide_LLVM_link target visibility)
+    llvm_map_components_to_libnames(comps ${ARGN})
+    target_link_libraries("${target}" "${visibility}" ${comps})
+endfunction()
+
+if (Halide_LLVM_FOUND)
+    set(Halide_LLVM_COMPONENTS "")
+    foreach (comp IN LISTS Halide_LLVM_FIND_COMPONENTS)
+        if (Halide_LLVM_${comp}_FOUND)
+            list(APPEND Halide_LLVM_COMPONENTS "${comp}")
+        endif ()
+    endforeach ()
+
+    if (NOT TARGET Halide_LLVM::Core)
+        add_library(Halide_LLVM::Core INTERFACE IMPORTED)
+
+        # LLVM_DEFINITIONS is a space-separated list instead of a more typical
+        # CMake semicolon-separated list. For a long time, CMake could handle
+        # this transparently but, since LLVM 17, the flag -D_FILE_OFFSET_BITS=64
+        # appears on 32-bit Linux. The presence of the `=` here stops CMake
+        # from splitting on spaces, instead corrupting the command line by
+        # folding the other flags into the value of -D_FILE_OFFSET_BITS=64.
+        # For better or worse, since the flag also appears twice, the second
+        # `=` is folded into the value of the first and we get errors of the
+        # form:
+        #
+        #   <command-line>: error: token "=" is not valid in preprocessor expressions
+        #
+        separate_arguments(LLVM_DEFINITIONS NATIVE_COMMAND "${LLVM_DEFINITIONS}")
+        list(REMOVE_ITEM LLVM_DEFINITIONS "-D_GLIBCXX_ASSERTIONS") # work around https://reviews.llvm.org/D142279
+        list(APPEND LLVM_DEFINITIONS "LLVM_VERSION=${LLVM_VERSION_MAJOR}${LLVM_VERSION_MINOR}")
+
+        target_compile_definitions(Halide_LLVM::Core INTERFACE ${LLVM_DEFINITIONS})
+        target_include_directories(Halide_LLVM::Core INTERFACE "${LLVM_INCLUDE_DIRS}")
+
+        set_property(TARGET Halide_LLVM::Core PROPERTY INTERFACE_CXX_RTTI "${LLVM_ENABLE_RTTI}")
+        set_property(TARGET Halide_LLVM::Core APPEND PROPERTY COMPATIBLE_INTERFACE_BOOL CXX_RTTI)
+
+        if (LLVM_LIBCXX GREATER -1)
+            target_compile_options(Halide_LLVM::Core INTERFACE "$<$<LINK_LANGUAGE:CXX>:-stdlib=libc++>")
+            target_link_options(Halide_LLVM::Core INTERFACE "$<$<LINK_LANGUAGE:CXX>:-stdlib=libc++>")
+        endif ()
+
+        if (Halide_LLVM_SHARED_LIBS)
+            target_link_libraries(Halide_LLVM::Core INTERFACE LLVM ${CMAKE_DL_LIBS})
+        else ()
+            _Halide_LLVM_link(Halide_LLVM::Core INTERFACE orcjit bitwriter linker passes)
+        endif ()
+    endif ()
+
+    foreach (comp IN LISTS Halide_LLVM_COMPONENTS)
+        if (NOT TARGET Halide_LLVM::${comp})
+            add_library(Halide_LLVM::${comp} INTERFACE IMPORTED)
+            target_link_libraries(Halide_LLVM::${comp} INTERFACE Halide_LLVM::Core)
+
+            if (NOT Halide_LLVM_SHARED_LIBS)
+                _Halide_LLVM_link(Halide_LLVM::${comp} INTERFACE ${comp})
+            endif ()
+
+            if (comp STREQUAL "WebAssembly")
+                target_include_directories(Halide_LLVM::WebAssembly INTERFACE ${LLD_INCLUDE_DIRS})
+                target_link_libraries(Halide_LLVM::WebAssembly INTERFACE lldWasm lldCommon)
+            endif ()
+        endif ()
+    endforeach ()
+endif ()

halide/lib/cmake/Halide/FindV8.cmake

@@ -0,0 +1,33 @@
+if (EXISTS "${V8_INCLUDE_PATH}")
+    message(DEPRECATION "V8_INCLUDE_PATH has been renamed to V8_INCLUDE_DIR")
+    set(V8_INCLUDE_DIR "${V8_INCLUDE_PATH}")
+    set(V8_INCLUDE_DIR "${V8_INCLUDE_PATH}" CACHE PATH "")
+endif ()
+
+find_path(V8_INCLUDE_DIR v8.h)
+
+if (EXISTS "${V8_LIB_PATH}")
+    message(DEPRECATION "V8_LIB_PATH has been renamed to V8_LIBRARY")
+    set(V8_LIBRARY "${V8_LIB_PATH}")
+    set(V8_LIBRARY "${V8_LIB_PATH}" CACHE FILEPATH "")
+endif ()
+
+find_library(
+    V8_LIBRARY
+    NAMES v8_monolith
+    PATH_SUFFIXES
+    out.gn/x64.release.sample/obj
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(
+    V8
+    REQUIRED_VARS V8_LIBRARY V8_INCLUDE_DIR
+    HANDLE_COMPONENTS
+)
+
+if (V8_FOUND AND NOT TARGET V8::V8)
+    add_library(V8::V8 UNKNOWN IMPORTED)
+    set_target_properties(V8::V8 PROPERTIES IMPORTED_LOCATION "${V8_LIBRARY}")
+    target_include_directories(V8::V8 INTERFACE "${V8_INCLUDE_DIR}")
+endif ()

halide/lib/cmake/Halide/Halide-shared-targets-release.cmake

@@ -0,0 +1,29 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Import target "Halide::Halide" for configuration "Release"
+set_property(TARGET Halide::Halide APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(Halide::Halide PROPERTIES
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/libHalide.dylib"
+  IMPORTED_SONAME_RELEASE "@rpath/libHalide.dylib"
+  )
+
+list(APPEND _cmake_import_check_targets Halide::Halide )
+list(APPEND _cmake_import_check_files_for_Halide::Halide "${_IMPORT_PREFIX}/lib/libHalide.dylib" )
+
+# Import target "Halide::GenGen" for configuration "Release"
+set_property(TARGET Halide::GenGen APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(Halide::GenGen PROPERTIES
+  IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/libHalide_GenGen.a"
+  )
+
+list(APPEND _cmake_import_check_targets Halide::GenGen )
+list(APPEND _cmake_import_check_files_for_Halide::GenGen "${_IMPORT_PREFIX}/lib/libHalide_GenGen.a" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)

halide/lib/cmake/Halide/Halide-shared-targets.cmake

@@ -0,0 +1,154 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
+   message(FATAL_ERROR "CMake >= 2.8.0 required")
+endif()
+if(CMAKE_VERSION VERSION_LESS "2.8.3")
+   message(FATAL_ERROR "CMake >= 2.8.3 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 2.8.3...3.26)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_cmake_targets_defined "")
+set(_cmake_targets_not_defined "")
+set(_cmake_expected_targets "")
+foreach(_cmake_expected_target IN ITEMS Halide::Halide Halide::Generator Halide::GenGen)
+  list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
+  if(TARGET "${_cmake_expected_target}")
+    list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
+  else()
+    list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}")
+  endif()
+endforeach()
+unset(_cmake_expected_target)
+if(_cmake_targets_defined STREQUAL _cmake_expected_targets)
+  unset(_cmake_targets_defined)
+  unset(_cmake_targets_not_defined)
+  unset(_cmake_expected_targets)
+  unset(CMAKE_IMPORT_FILE_VERSION)
+  cmake_policy(POP)
+  return()
+endif()
+if(NOT _cmake_targets_defined STREQUAL "")
+  string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}")
+  string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}")
+  message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n")
+endif()
+unset(_cmake_targets_defined)
+unset(_cmake_targets_not_defined)
+unset(_cmake_expected_targets)
+
+
+# Compute the installation prefix relative to this file.
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+if(_IMPORT_PREFIX STREQUAL "/")
+  set(_IMPORT_PREFIX "")
+endif()
+
+# Create imported target Halide::Halide
+add_library(Halide::Halide SHARED IMPORTED)
+
+set_target_properties(Halide::Halide PROPERTIES
+  COMPATIBLE_INTERFACE_BOOL "CXX_RTTI"
+  INTERFACE_COMPILE_DEFINITIONS "HALIDE_VERSION_MAJOR=19;HALIDE_VERSION_MINOR=0;HALIDE_VERSION_PATCH=0;HALIDE_ENABLE_RTTI;HALIDE_WITH_EXCEPTIONS"
+  INTERFACE_COMPILE_FEATURES "cxx_std_17"
+  INTERFACE_LINK_LIBRARIES "Halide::Runtime"
+)
+
+if(NOT CMAKE_VERSION VERSION_LESS "3.23.0")
+  target_sources(Halide::Halide
+    INTERFACE
+      FILE_SET "HEADERS"
+      TYPE "HEADERS"
+      BASE_DIRS "${_IMPORT_PREFIX}/include"
+      FILES "${_IMPORT_PREFIX}/include/Halide.h"
+  )
+else()
+  set_property(TARGET Halide::Halide
+    APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES
+      "${_IMPORT_PREFIX}/include"
+  )
+endif()
+
+# Create imported target Halide::Generator
+add_library(Halide::Generator INTERFACE IMPORTED)
+
+set_target_properties(Halide::Generator PROPERTIES
+  INTERFACE_LINK_LIBRARIES "\$<LINK_LIBRARY:WHOLE_ARCHIVE,Halide::GenGen>"
+)
+
+# Create imported target Halide::GenGen
+add_library(Halide::GenGen STATIC IMPORTED)
+
+set_target_properties(Halide::GenGen PROPERTIES
+  INTERFACE_LINK_LIBRARIES "Halide::Halide"
+)
+
+if(CMAKE_VERSION VERSION_LESS 3.0.0)
+  message(FATAL_ERROR "This file relies on consumers using CMake 3.0.0 or greater.")
+endif()
+
+# Load information for each installed configuration.
+file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Halide-shared-targets-*.cmake")
+foreach(_cmake_config_file IN LISTS _cmake_config_files)
+  include("${_cmake_config_file}")
+endforeach()
+unset(_cmake_config_file)
+unset(_cmake_config_files)
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(_cmake_target IN LISTS _cmake_import_check_targets)
+  foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
+    if(NOT EXISTS "${_cmake_file}")
+      message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
+   \"${_cmake_file}\"
+but this file does not exist.  Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+   \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+    endif()
+  endforeach()
+  unset(_cmake_file)
+  unset("_cmake_import_check_files_for_${_cmake_target}")
+endforeach()
+unset(_cmake_target)
+unset(_cmake_import_check_targets)
+
+# Make sure the targets which have been exported in some other
+# export set exist.
+unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets)
+foreach(_target "Halide::Runtime" )
+  if(NOT TARGET "${_target}" )
+    set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}")
+  endif()
+endforeach()
+
+if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets)
+  if(CMAKE_FIND_PACKAGE_NAME)
+    set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE)
+    set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}")
+  else()
+    message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}")
+  endif()
+endif()
+unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets)
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)