Fix DTrace

This syncs DTrace build with current changes and practices.

FindDTrace module defines INTERFACE libraries which are further used
as done in main. Similarly can be done for PHP extensions but a bit more
adjustments are needed for that generated header prefix patching.

Author: petk

cmake/cmake/modules/FindDTrace.cmake

@@ -1,8 +1,12 @@
 #[=============================================================================[
-# FindDtrace
+# FindDTrace
 
 Find DTrace.
 
+Module defines the following `IMPORTED` target(s):
+
+* `DTrace::DTrace` - The package library, if found.
+
 ## Result variables
 
 * `DTrace_FOUND` - Whether DTrace library is found.
@@ -11,28 +15,52 @@ Find DTrace.
 
 * `DTrace_INCLUDE_DIR` - Directory containing DTrace library headers.
 * `DTrace_EXECUTABLE` - Path to the DTrace command-line utility.
-* `HAVE_DTRACE` - Whether DTrace support is enabled.
 
 ## Functions provided by this module
 
 Module defines the following function to initialize the DTrace support.
 
 ```cmake
 dtrace_target(
-  TARGET <target-name>
+  <target-name>
   INPUT <input>
   HEADER <header>
   SOURCES <source>...
   [INCLUDES <includes>...]
 )
 ```
 
-* `TARGET` - Target name to append the generated DTrace probe definition object
-  file.
-* `INPUT` - Name of the file with DTrace probe descriptions.
-* `HEADER` - Name of the DTrace probe header file.
-* `SOURCES` - A list of project source files to build DTrace object.
+Generates DTrace header `<header>` and creates `INTERFACE` library
+`<target-name>` with probe definition object file added as INTERFACE source.
+
+* `<target-name>` - DTrace INTERFACE library with the generated DTrace probe
+  definition object file.
+* `INPUT` - Name of the file with DTrace probe descriptions. Relative path is
+  interpreted as being relative to the current source directory.
+* `HEADER` - Name of the DTrace probe header file to be generated. Relative path
+  is interpreted as being relative to the current binary directory.
+* `SOURCES` - A list of source files to build DTrace object. Relative paths are
+  interpreted as being relative to the current source directory.
 * `INCLUDES` - A list of include directories for appending to DTrace object.
+
+## Basic usage
+
+```cmake
+# CMakeLists.txt
+
+find_package(DTrace)
+
+dtrace_target(
+  foo_dtrace
+  INPUT foo_dtrace.d
+  HEADER foo_dtrace_generated.h
+  SOURCES foo.c ...
+)
+target_link_libraries(foo PRIVATE DTrace::DTrace)
+
+add_executable(bar)
+target_link_libraries(bar PRIVATE foo_dtrace)
+```
 #]=============================================================================]
 
 include(FeatureSummary)
@@ -84,15 +112,23 @@ if(NOT DTrace_FOUND)
   return()
 endif()
 
-set(HAVE_DTRACE 1 CACHE INTERNAL "Whether to enable DTrace support")
+if(NOT TARGET DTrace::DTrace)
+  add_library(DTrace::DTrace INTERFACE IMPORTED)
+  set_target_properties(
+    DTrace::DTrace
+    PROPERTIES
+      INTERFACE_INCLUDE_DIRECTORIES ${DTrace_INCLUDE_DIR}
+  )
+endif()
 
 function(dtrace_target)
   cmake_parse_arguments(
-    parsed                # prefix
-    ""                    # options
-    "TARGET;INPUT;HEADER" # one-value keywords
-    "SOURCES;INCLUDES"    # multi-value keywords
-    ${ARGN}               # strings to parse
+    PARSE_ARGV
+    1
+    parsed             # prefix
+    ""                 # options
+    "INPUT;HEADER"     # one-value keywords
+    "SOURCES;INCLUDES" # multi-value keywords
   )
 
   if(parsed_UNPARSED_ARGUMENTS)
@@ -103,14 +139,10 @@ function(dtrace_target)
     message(FATAL_ERROR "Missing values for: ${parsed_KEYWORDS_MISSING_VALUES}")
   endif()
 
-  if(NOT parsed_TARGET)
+  if(NOT ARGV0)
     message(FATAL_ERROR "dtrace_target expects a target name")
   endif()
 
-  if(NOT TARGET ${parsed_TARGET})
-    message(FATAL_ERROR "dtrace_target: ${parsed_TARGET} is not a target")
-  endif()
-
   if(NOT parsed_INPUT)
     message(FATAL_ERROR "dtrace_target expects an input filename")
   endif()
@@ -123,64 +155,92 @@ function(dtrace_target)
     message(FATAL_ERROR "dtrace_target expects a list of source files")
   endif()
 
-  # Generate DTrace header.
-  add_custom_command(
-    OUTPUT "${parsed_HEADER}"
-    COMMAND ${DTrace_EXECUTABLE}
-      -s "${parsed_INPUT}"
-      -h                    # Generate a systemtap header file.
-      -C                    # Run the cpp preprocessor on the input file.
-      -o "${parsed_HEADER}" # Name of the output file.
-    DEPENDS "${parsed_INPUT}"
-    COMMENT "[DTrace] Generating DTrace ${parsed_HEADER}"
-    VERBATIM
-  )
+  if(NOT IS_ABSOLUTE "${parsed_INPUT}")
+    set(parsed_INPUT ${CMAKE_CURRENT_SOURCE_DIR}/${parsed_INPUT})
+  endif()
 
-  # Patch DTrace header.
+  if(NOT IS_ABSOLUTE "${parsed_HEADER}")
+    set(parsed_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${parsed_HEADER})
+  endif()
+
+  set(sources)
+  foreach(source IN LISTS parsed_SOURCES)
+    if(NOT IS_ABSOLUTE ${source})
+      set(source ${CMAKE_CURRENT_SOURCE_DIR}/${source})
+    endif()
+    list(APPEND sources ${source})
+  endforeach()
+  set(parsed_SOURCES ${sources})
+
+  # Generate DTrace header.
   file(
     GENERATE
-    OUTPUT CMakeFiles/PatchDTraceHeader.cmake
+    OUTPUT CMakeFiles/GenerateDTraceHeader.cmake
     CONTENT [[
-      file(READ "${DTRACE_HEADER_FILE}" content)
+      execute_process(
+        COMMAND ${DTrace_EXECUTABLE}
+          -s "${parsed_INPUT}"
+          -h                    # Generate a systemtap header file.
+          -C                    # Run the cpp preprocessor on the input file.
+          -o "${parsed_HEADER}" # Name of the output file.
+      )
+      # Patch DTrace header.
+      file(READ "${parsed_HEADER}" content)
       string(REPLACE "PHP_" "DTRACE_" content "${content}")
-      file(WRITE "${DTRACE_HEADER_FILE}" "${content}")
+      file(WRITE "${parsed_HEADER}" "${content}")
     ]]
   )
-  add_custom_target(
-    ${parsed_TARGET}_patch_header
+  cmake_path(
+    RELATIVE_PATH parsed_HEADER
+    BASE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    OUTPUT_VARIABLE header
+  )
+  add_custom_command(
+    OUTPUT ${parsed_HEADER}
     COMMAND ${CMAKE_COMMAND}
-      -DDTRACE_HEADER_FILE=${parsed_HEADER}
-      -P CMakeFiles/PatchDTraceHeader.cmake
-    DEPENDS ${parsed_HEADER}
-    COMMENT "[DTrace] Patching ${parsed_HEADER}"
+      -DDTrace_EXECUTABLE=${DTrace_EXECUTABLE}
+      -Dparsed_HEADER=${parsed_HEADER}
+      -Dparsed_INPUT=${parsed_INPUT}
+      -P CMakeFiles/GenerateDTraceHeader.cmake
+    DEPENDS "${parsed_INPUT}"
+    COMMENT "[DTrace] Generating ${header}"
+    VERBATIM
+    COMMAND_EXPAND_LISTS
   )
 
-  add_library(${parsed_TARGET}_object OBJECT ${parsed_SOURCES})
-
-  add_dependencies(${parsed_TARGET}_object ${parsed_TARGET}_patch_header)
-
-  target_include_directories(
-    ${parsed_TARGET}_object
-    PRIVATE
-      ${DTrace_INCLUDE_DIR}
-      ${parsed_INCLUDES}
-  )
+  # Generate DTrace object.
+  set(target ${ARGV0})
+  add_library(${target}_object OBJECT ${parsed_SOURCES} ${parsed_HEADER})
+  target_link_libraries(${target}_object PRIVATE DTrace::DTrace)
+  target_include_directories(${target}_object PRIVATE ${parsed_INCLUDES})
 
   cmake_path(GET parsed_INPUT FILENAME input)
-  set(output_filename CMakeFiles/${input}.o)
+  set(output CMakeFiles/${input}.o)
+  cmake_path(GET CMAKE_CURRENT_BINARY_DIR FILENAME parent)
 
   add_custom_command(
-    OUTPUT ${output_filename}
-    COMMAND CC="${CMAKE_C_COMPILER}" ${DTrace_EXECUTABLE}
-      -s ${parsed_INPUT} $<TARGET_OBJECTS:${parsed_TARGET}_object>
+    OUTPUT ${output}
+    COMMAND
+      CC="${CMAKE_C_COMPILER}"
+      ${DTrace_EXECUTABLE}
+      -s ${parsed_INPUT} $<TARGET_OBJECTS:${target}_object>
       -G # Generate a systemtap probe definition object file.
-      -o ${output_filename}
+      -o ${output}
       -I${DTrace_INCLUDE_DIR}
-    DEPENDS ${parsed_TARGET}_object
-    COMMENT "[DTrace] Generating DTrace probe object ${output_filename}"
+    DEPENDS ${target}_object
+    COMMENT "[DTrace] Generating DTrace probe object ${parent}/${output}"
     VERBATIM
+    COMMAND_EXPAND_LISTS
   )
-
-  target_sources(${parsed_TARGET} PRIVATE ${output_filename})
-  target_include_directories(${parsed_TARGET} PUBLIC ${DTrace_INCLUDE_DIR})
+  add_custom_target(${target}_generator DEPENDS ${output})
+
+  add_library(${target} INTERFACE)
+  target_sources(${target} INTERFACE ${CMAKE_CURRENT_BINARY_DIR}/${output})
+  set_source_files_properties(
+    ${CMAKE_CURRENT_BINARY_DIR}/${output}
+    PROPERTIES
+      EXTERNAL_OBJECT TRUE
+      GENERATED TRUE
+  )
+  add_dependencies(${target} ${target}_generator)
 endfunction()

cmake/main/CMakeLists.txt

@@ -199,11 +199,11 @@ if(PHP_DTRACE)
 
   if(DTrace_FOUND)
     dtrace_target(
-      TARGET php_main
+      php_dtrace
       INPUT ${PHP_SOURCE_DIR}/Zend/zend_dtrace.d
       HEADER ${PHP_BINARY_DIR}/Zend/zend_dtrace_gen.h
       SOURCES
-        ${PHP_SOURCE_DIR}/main/main.c
+        main.c
         ${PHP_SOURCE_DIR}/Zend/zend_API.c
         ${PHP_SOURCE_DIR}/Zend/zend_dtrace.c
         ${PHP_SOURCE_DIR}/Zend/zend_exceptions.c
@@ -212,6 +212,10 @@ if(PHP_DTRACE)
       INCLUDES
         $<TARGET_PROPERTY:PHP::configuration,INTERFACE_INCLUDE_DIRECTORIES>
     )
+    target_link_libraries(php_main PRIVATE DTrace::DTrace)
+    target_link_libraries(php INTERFACE php_dtrace)
+
+    set(HAVE_DTRACE 1 PARENT_SCOPE)
 
     message(CHECK_PASS "yes")
   else()
@@ -249,7 +253,7 @@ if(PHP_DMALLOC)
 
   if(Dmalloc_FOUND)
     message(CHECK_PASS "yes")
-    set(HAVE_DMALLOC 1 CACHE INTERNAL "Whether the Dmalloc library is available")
+    set(HAVE_DMALLOC 1 PARENT_SCOPE)
   else()
     message(CHECK_FAIL "no")
   endif()