Allow static building of the monolithic dawn library: (lib)webgpu_dawn

- Update BundleLibraries to take another argument (STATIC or SHARED)
- Change DAWN_BUILD_MONOLITHIC_LIBRARY from OFF/ON to OFF/STATIC/SHARED

This is an imported pull request from
google#33

GITHUB_PR_HEAD_SHA=74b9f13d2c44fbdc8bc8cbede44325ff1f75b164
ORIGINAL_AUTHOR=Manuel <[email protected]>
GitOrigin-RevId: 44f76ba
Change-Id: I69dc673656e43c6c1a3c710ece00ecf16a8b9cde

Author: manuel5975p

CMakeLists.txt

@@ -335,11 +335,10 @@ message(STATUS "Webgpu IDL path: ${WEBGPU_IDL_PATH}")
 message(STATUS "Go exe: ${GO_EXECUTABLE}")
 message(STATUS "")
 
-option(DAWN_FETCH_DEPENDENCIES "Use fetch_dawn_dependencies.py as an alternative to using depot_tools" OFF)
-option(DAWN_BUILD_MONOLITHIC_LIBRARY "Bundle all dawn components into a single shared library." ON)
+option(DAWN_BUILD_MONOLITHIC_LIBRARY "Build one big monolithic library file" ON)
 
-message(STATUS "Dawn fetch dependencies: ${DAWN_FETCH_DEPENDENCIES}")
 message(STATUS "Dawn build monolithic library: ${DAWN_BUILD_MONOLITHIC_LIBRARY}")
+message(STATUS "Dawn fetch dependencies: ${DAWN_FETCH_DEPENDENCIES}")
 message(STATUS "")
 
 # Much of the backend code is shared among desktop OpenGL and OpenGL ES

src/cmake/BundleLibraries.cmake

@@ -25,49 +25,121 @@
 # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-function(bundle_libraries output_target)
+function(bundle_libraries output_target library_type)
+
+  # 1. Validate the library_type argument
+  string(TOUPPER ${library_type} upper_library_type)
+  if(NOT (upper_library_type STREQUAL "STATIC" OR upper_library_type STREQUAL "SHARED"))
+    message(FATAL_ERROR "bundle_libraries: Invalid library type specified '${library_type}'. Must be STATIC or SHARED for target '${output_target}'.")
+    return() # Fatal error stops execution, but return is good practice
+  endif()
+
+  # Use the validated type in upper case
+  set(_target_type ${upper_library_type})
+
+  # --- Inner helper function to get dependencies ---
+  # This function recursively finds all dependencies of a given target.
+  # It populates a list variable named 'all_dependencies' in the parent scope.
+  # Note: This recursive approach with PARENT_SCOPE works but can be a bit
+  # tricky with variable lifetimes. It assumes 'all_dependencies' is
+  # initialized in the calling scope.
   function(get_dependencies input_target)
+    # Resolve aliases first
     get_target_property(alias ${input_target} ALIASED_TARGET)
     if(TARGET ${alias})
       set(input_target ${alias})
     endif()
+
+    # Avoid processing the same target multiple times (circular dependency check)
+    # Checks if the current target is already in the list being built in the parent scope.
+    # Note: all_dependencies is modified in parent scope below, so check works.
     if(${input_target} IN_LIST all_dependencies)
+      #message("DEBUG: Already processed ${input_target}")
       return()
     endif()
+
+    # Add the current target to the list in the parent scope
+    # list(APPEND) modifies the variable in the current scope.
+    # set(... PARENT_SCOPE) copies the current scope's variable to the parent scope.
+    # This pattern, while slightly verbose, works for recursive list building across scopes.
     list(APPEND all_dependencies ${input_target})
+    set(all_dependencies ${all_dependencies} PARENT_SCOPE) # Propagate change up
 
+    # Get dependencies from LINK_LIBRARIES (Private and Public linkage)
     get_target_property(link_libraries ${input_target} LINK_LIBRARIES)
     foreach(dependency IN LISTS link_libraries)
+      # Only recurse on actual targets
       if(TARGET ${dependency})
-        get_dependencies(${dependency})
+        #message("DEBUG: Recursing into LINK_LIBRARIES dependency: ${dependency}")
+        get_dependencies(${dependency}) # Recursive call
       endif()
     endforeach()
 
-    get_target_property(link_libraries ${input_target} INTERFACE_LINK_LIBRARIES)
-    foreach(dependency IN LISTS link_libraries)
+    # Get dependencies from INTERFACE_LINK_LIBRARIES (Interface and Public linkage)
+    get_target_property(interface_link_libraries ${input_target} INTERFACE_LINK_LIBRARIES)
+    foreach(dependency IN LISTS interface_link_libraries)
+      # Only recurse on actual targets
       if(TARGET ${dependency})
-        get_dependencies(${dependency})
+        get_dependencies(${dependency}) # Recursive call
       endif()
     endforeach()
 
-    set(all_dependencies ${all_dependencies} PARENT_SCOPE)
-  endfunction()
+    # The final 'all_dependencies' list is available in the parent scope
+    # after the initial call to get_dependencies completes.
+
+  endfunction() # End of get_dependencies helper function
+  # --- End of inner helper function ---
+
+  # Initialize the list that the recursive function will populate.
+  # This list will exist in the scope of the bundle_libraries function.
+  set(all_dependencies "")
+
+  # 2. Get dependencies for all input targets provided in ARGN
+  # ARGN contains all arguments *after* the named parameters (output_target, library_type)
+  if(NOT ARGN)
+     message(FATAL_ERROR "bundle_libraries: No input targets specified for '${output_target}'.")
+     return()
+  endif()
 
   foreach(input_target IN LISTS ARGN)
-    get_dependencies(${input_target})
+    if(TARGET ${input_target})
+      #message("DEBUG: Starting dependency analysis for input target: ${input_target}")
+      get_dependencies(${input_target})
+    else()
+      message(WARNING "bundle_libraries: Input target '${input_target}' is not a valid target. Skipping.")
+    endif()
   endforeach()
 
+  #message("DEBUG: Collected dependencies: ${all_dependencies}")
+
+  # 3. Collect $<TARGET_OBJECTS:...> from STATIC and OBJECT library dependencies
+  set(all_objects "")
   foreach(dependency IN LISTS all_dependencies)
     get_target_property(type ${dependency} TYPE)
+    # message("DEBUG: Checking dependency ${dependency} with type ${type}")
+
+    # We only want object files from static or object libraries.
+    # This correctly excludes shared libraries, modules, executables, interfaces, etc.
     if(${type} STREQUAL "STATIC_LIBRARY")
       list(APPEND all_objects $<TARGET_OBJECTS:${dependency}>)
     elseif(${type} STREQUAL "OBJECT_LIBRARY")
       list(APPEND all_objects $<TARGET_OBJECTS:${dependency}>)
     endif()
   endforeach()
 
-  add_library(${output_target} SHARED ${all_objects})
+  # message("DEBUG: Collected objects: ${all_objects}")
+
+  # Check if any object files were found
+  if(NOT all_objects)
+    message(WARNING "bundle_libraries: No object files found from the dependencies of ${ARGN}. Creating empty library '${output_target}' as ${_target_type}.")
+  endif()
+
+  # 4. Create the output library using the validated type and collected objects
+  # If all_objects is empty, add_library will still create an empty library of the specified type.
+  add_library(${output_target} ${_target_type} ${all_objects})
 
+  # 5. Add dependencies to ensure input targets are built before the bundled library.
+  # This handles the build order correctly.
   add_dependencies(${output_target} ${ARGN})
 
 endfunction()

src/dawn/native/CMakeLists.txt

@@ -920,22 +920,39 @@ if (DAWN_BUILD_MONOLITHIC_LIBRARY)
     )
     # Bundle all objects of dawn_native, it's public dependencies and private dependencies.
     include(BundleLibraries)
-    bundle_libraries(webgpu_dawn dawn::dawn_native_objects)
+    if(BUILD_SHARED_LIBS)
+        bundle_libraries(webgpu_dawn SHARED dawn::dawn_native_objects)
+    else()
+        bundle_libraries(webgpu_dawn STATIC dawn::dawn_native_objects)
+    endif()
+
     add_library(dawn::webgpu_dawn ALIAS webgpu_dawn)
     # Compile backend specific sources along with webgpu_dawn_native_proc sources for export macros to get applied.
     target_sources(webgpu_dawn
         PRIVATE
         ${WEBGPU_DAWN_NATIVE_PROC_GEN_SOURCES}
         ${dawn_component_srcs}
     )
-    target_compile_definitions(webgpu_dawn
-        PRIVATE
-            "WGPU_IMPLEMENTATION"
-            "DAWN_NATIVE_IMPLEMENTATION"
-        PUBLIC
-            "WGPU_SHARED_LIBRARY"
-            "DAWN_NATIVE_SHARED_LIBRARY"
-    )
+    if(BUILD_SHARED_LIBS)
+        target_compile_definitions(webgpu_dawn
+            PRIVATE
+                "WGPU_IMPLEMENTATION"
+                "DAWN_NATIVE_IMPLEMENTATION"
+            PUBLIC
+                "WGPU_SHARED_LIBRARY"
+                "DAWN_NATIVE_SHARED_LIBRARY"
+        )
+    
+    else()
+        target_compile_definitions(webgpu_dawn
+            PRIVATE
+                "WGPU_IMPLEMENTATION"
+                "DAWN_NATIVE_IMPLEMENTATION"
+            PUBLIC
+                "WGPU_STATIC_LIBRARY" # Here it's simply important that we do not define WGPU_SHARED_LIBRARY, as this will set dllimport / export attributes on windows.
+                "DAWN_NATIVE_STATIC_LIBRARY"
+        )    
+    endif()
     # Apart from dawn_public_config, everything else goes inside PRIVATE, otherwise install rules will complain that they were not exported.
     target_link_libraries(webgpu_dawn
         PUBLIC