Fix #2284, improve add_cfe_tables function

Improves the functionality and adds additional documentation about
how this function is intended to work.  The improvements add some
flexibility and intelligence and should be backward compatible with
existing use cases.

The add_cfe_app() function now adds an additional interface target that
can be referenced when building tables, and this includes the
directory-scope properties from the original app build.  Therefore,
calls to add_cfe_tables from other (non-app) contexts can get the full
set of include directories.

This also makes the target name simpler when adding custom properties,
it is simply "${APP_NAME}.table"

Finally, instead of invoking the table tool (elf2cfetbl) directly in the
context of the table build rule, it generates a custom makefile rule
instead, which is called from the top-level (mission) scope to do the
conversions.

cmake/arch_build.cmake

@@ -106,6 +106,30 @@ function(add_cfe_app APP_NAME APP_SRC_FILES)
     cfs_app_do_install(${APP_NAME} ${APP_DYNAMIC_TARGET_LIST})
   endif (APP_DYNAMIC_TARGET_LIST)
 
+  # Add an interface target is added with a ".table" suffix,
+  # this should reflect all the INCLUDE_DIRECTORIES and COMPILE_DEFINITIONS that
+  # were used when compiling the app itself, such that tables (and other items) can be
+  # added later and reference the same set.
+  add_library(${APP_NAME}.table INTERFACE)
+  get_directory_property(CURRENT_INCLUDE_DIRS INCLUDE_DIRECTORIES)
+  if (NOT CURRENT_INCLUDE_DIRS)
+    set(CURRENT_INCLUDE_DIRS) # make it empty, not -NOTFOUND
+  endif()
+  get_directory_property(CURRENT_COMPILE_DEFS COMPILE_DEFINITIONS)
+  if (NOT CURRENT_COMPILE_DEFS)
+    set(CURRENT_COMPILE_DEFS) # make it empty, not -NOTFOUND
+  endif()
+  list (APPEND CURRENT_INCLUDE_DIRS
+    $<TARGET_PROPERTY:${APP_NAME},INCLUDE_DIRECTORIES>
+    $<TARGET_PROPERTY:core_api,INTERFACE_INCLUDE_DIRECTORIES>
+  )
+  list (APPEND CURRENT_COMPILE_DEFS
+    $<TARGET_PROPERTY:${APP_NAME},COMPILE_DEFINITIONS>
+    $<TARGET_PROPERTY:core_api,INTERFACE_COMPILE_DEFINITIONS>
+  )
+  target_include_directories(${APP_NAME}.table INTERFACE ${CURRENT_INCLUDE_DIRS})
+  target_compile_definitions(${APP_NAME}.table INTERFACE ${CURRENT_COMPILE_DEFS} CFE_APP_NAME="${APP_NAME}")
+
 endfunction(add_cfe_app)
 
 ##################################################################
@@ -146,99 +170,160 @@ endfunction(add_cfe_app_dependency)
 #
 # Simplified routine to add CFS tables to be built with an app
 #
-function(add_cfe_tables APP_NAME TBL_SRC_FILES)
+# For apps with just a single table, the TABLE_FQNAME may be the
+# same as the app name, which is simple.
+#
+# For apps with multiple tables, the TABLE_FQNAME may be of the
+# form "${APP_NAME}.${TABLE_NAME}" where ${APP_NAME} refers to an
+# app target that was registered via the "add_cfe_app" function.
+#
+# Note that for backward compatibility, any name will be accepted
+# for TABLE_FQNAME.  However if this function cannot determine which
+# app the table is associated with, it will only have a default set
+# of INCLUDE_DIRECTORIES when building the C source file(s).  By
+# associating a table with an app using the conventions above, the
+# INCLUDE_DIRECTORIES from the parent app will be used when building the
+# tables.
+#
+# This function produces one or more library targets in CMake, using names
+# of the form: "tblobj_${TGT}_{TABLE_FQNAME}" where TGT reflects the name
+# of the target from targets.cmake and TABLE_FQNAME reflects the first
+# parameter to this function.
+#
+function(add_cfe_tables TABLE_FQNAME TBL_DEFAULT_SRC_FILES)
+
+    get_filename_component(APP_NAME ${TABLE_FQNAME} NAME_WE)
 
-    if (TGTNAME)
-        set (TABLE_TGTLIST ${TGTNAME})
-    elseif (TARGET ${APP_NAME})
+    # If "TGTNAME" is set, then use it directly
+    set(TABLE_TGTLIST ${TGTNAME})
+    set(TABLE_TEMPLATE "${CFE_SOURCE_DIR}/cmake/tables/table_rule_template.d.in")
+    set(TABLE_CMD_BASIC_OPTS
+      -DTEMPLATE_FILE="${TABLE_TEMPLATE}"
+      -DAPP_NAME="${APP_NAME}"
+    )
+
+    if (INSTALL_SUBDIR)
+      list(APPEND TABLE_CMD_BASIC_OPTS
+        -DINSTALL_SUBDIR="${INSTALL_SUBDIR}"
+      )
+    endif()
+
+    if (TARGET ${APP_NAME}.table)
+      if (NOT TABLE_TGTLIST)
         set (TABLE_TGTLIST ${TGTLIST_${APP_NAME}})
+      endif()
+      set(TABLE_PARENT_TGT ${APP_NAME}.table)
     else()
-        # The first parameter should match the name of an app that was
-        # previously defined using "add_cfe_app".  If target-scope properties
-        # are used for include directories and compile definitions, this is needed
-        # to compile tables with the same include path/definitions as the app has.
-        # However historically this could have been any string, which still works
-        # if directory-scope properties are used for includes, so this is not
-        # an error.
-        message("NOTE: \"${APP_NAME}\" passed to add_cfe_tables is not a previously-defined application target")
+      # The first parameter should match the name of an app that was
+      # previously defined using "add_cfe_app".  If target-scope properties
+      # are used for include directories and compile definitions, this is needed
+      # to compile tables with the same include path/definitions as the app has.
+      # However historically this could have been any string, which still works
+      # if directory-scope properties are used for includes, so this is not
+      # an error.
+      message("NOTE: \"${APP_NAME}\" passed to add_cfe_tables is not a previously-defined application target")
+      if (NOT TABLE_TGTLIST)
         set (TABLE_TGTLIST ${APP_STATIC_TARGET_LIST} ${APP_DYNAMIC_TARGET_LIST})
+      endif()
+      # No (known) parent app, just use core_api in this case.  It will only get global-scope includes and defines.
+      set(TABLE_PARENT_TGT core_api)
     endif()
 
+    set(TABLE_GENSCRIPT "${CFE_SOURCE_DIR}/cmake/tables/generate_elf_table_rules.cmake")
+
     # The table source must be compiled using the same "include_directories"
     # as any other target, but it uses the "add_custom_command" so there is
     # no automatic way to do this (at least in the older cmakes)
+    foreach(TGT ${TABLE_TGTLIST})
+
+      set(TABLE_CMD_TGT_OPTS
+        -DTARGET_NAME="${TGT}"
+      )
+
+      set(TABLE_LIBNAME "tblobj_${TGT}_${TABLE_FQNAME}")
+      list(APPEND TABLE_CMD_TGT_OPTS "-DARCHIVE_FILE=\"$<TARGET_FILE:${TABLE_LIBNAME}>\"")
+
+      # Note that the TBL_DEFAULT_SRC_FILES is just a default - we now need
+      # to find the active source, which typically comes from the MISSION_DEFS dir.
+      # The TABLE_SELECTED_SRCS will become this list of active/selected source files
+      set(TABLE_SELECTED_SRCS)
+      foreach(TBL ${TBL_DEFAULT_SRC_FILES} ${ARGN})
+
+        # The file source basename (without directory or ext) should be the same as the table
+        # binary filename with a ".tbl" extension (this is the convention assumed by elf2cfetbl)
+        get_filename_component(TABLE_SRC_NEEDED ${TBL} NAME)
+        get_filename_component(TABLE_BASENAME   ${TBL} NAME_WE)
+
+
+        # Check if an override exists at the mission level (recommended practice)
+        # This allows a mission to implement a customized table without modifying
+        # the original - this also makes for easier merging/updating if needed.
+        # Note this path list is in reverse-priority order, and only a single file
+        # will be end up being selected.
+        cfe_locate_implementation_file(TBL_SRC "${TABLE_SRC_NEEDED}"
+          OPTIONAL
+          FALLBACK_FILE "${CMAKE_CURRENT_SOURCE_DIR}/${TBL}"
+          PREFIX ${TGT}
+          SUBDIR tables
+        )
+
+        list(APPEND TABLE_SELECTED_SRCS ${TBL_SRC})
+
+        if (TBL_SRC)
+          message(STATUS "Using ${TBL_SRC} as table definition for ${TABLE_BASENAME} on ${TGT}")
+        else()
+          message(FATAL_ERROR "No table definition for ${APP_NAME}.${TABLE_BASENAME} on ${TGT} found")
+        endif()
+
+        # Set a preprocessor macro so when the .c file is compiled it knows what its
+        # input and (by convention) output name is supposed to be.
+        if (TABLE_LIBNAME)
+          set_property(SOURCE "${TBL_SRC}" APPEND PROPERTY COMPILE_DEFINITIONS
+            CFE_TABLE_NAME=${TABLE_BASENAME}
+          )
+        endif()
+
+        # Note the table is not generated directly here, as it may require the native system compiler, so
+        # the call to the table tool (eds2cfetbl in this build) is deferred to the parent scope.  Instead, this
+        # generates a file that captures the state (include dirs, source files, targets) for use in a future step.
+        set(TABLE_RULEFILE "${MISSION_BINARY_DIR}/tables/${TGT}_${TABLE_FQNAME}.${TABLE_BASENAME}.d")
+        add_custom_command(
+          OUTPUT "${TABLE_RULEFILE}"
+          COMMAND ${CMAKE_COMMAND}
+            ${TABLE_CMD_BASIC_OPTS}
+            ${TABLE_CMD_TGT_OPTS}
+            -DOUTPUT_FILE="${TABLE_RULEFILE}"
+            -DTABLE_NAME="${TABLE_BASENAME}"
+            -DSOURCES="${TBL_SRC}"
+            -P "${TABLE_GENSCRIPT}"
+          WORKING_DIRECTORY
+            ${WORKING_DIRECTORY}
+          DEPENDS
+            ${TABLE_TEMPLATE}
+            ${TABLE_GENSCRIPT}
+            ${TABLE_PARENT_TGT}
+        )
+
+        # Add a custom target to generate the config file
+        add_custom_target(generate_table_${TGT}_${APP_NAME}_${TABLE_BASENAME}
+            DEPENDS "${TABLE_RULEFILE}"
+        )
+        add_dependencies(cfetables generate_table_${TGT}_${APP_NAME}_${TABLE_BASENAME})
+
+      endforeach()
+
+      if (TABLE_LIBNAME)
+        # NOTE: On newer CMake versions this should become an OBJECT library which makes this simpler.
+        # On older versions one may not reference the TARGET_OBJECTS property from the custom command.
+        # As a workaround this is built into a static library, and then the desired object is extracted
+        # before passing to elf2cfetbl.  It is roundabout but it works.
+        add_library(${TABLE_LIBNAME} STATIC ${TABLE_SELECTED_SRCS})
+        target_compile_definitions(${TABLE_LIBNAME} PRIVATE
+          CFE_CPU_NAME=${TGT}
+        )
+        target_link_libraries(${TABLE_LIBNAME} ${TABLE_PARENT_TGT})
+      endif()
 
-    # Create the intermediate table objects using the target compiler,
-    # then use "elf2cfetbl" to convert to a .tbl file
-    foreach(TBL ${TBL_SRC_FILES} ${ARGN})
-
-        # Get name without extension (NAME_WE) and append to list of tables
-        get_filename_component(TBLWE ${TBL} NAME_WE)
-
-        foreach(TGT ${TABLE_TGTLIST})
-            set(TABLE_LIBNAME "${TGT}_${APP_NAME}_${TBLWE}")
-            set(TABLE_DESTDIR "${CMAKE_CURRENT_BINARY_DIR}/${TABLE_LIBNAME}")
-            set(TABLE_BINARY  "${TABLE_DESTDIR}/${TBLWE}.tbl")
-            file(MAKE_DIRECTORY ${TABLE_DESTDIR})
-
-            # Check if an override exists at the mission level (recommended practice)
-            # This allows a mission to implement a customized table without modifying
-            # the original - this also makes for easier merging/updating if needed.
-            if (EXISTS "${MISSION_DEFS}/tables/${TGT}_${TBLWE}.c")
-                set(TBL_SRC "${MISSION_DEFS}/tables/${TGT}_${TBLWE}.c")
-            elseif (EXISTS "${MISSION_SOURCE_DIR}/tables/${TGT}_${TBLWE}.c")
-                set(TBL_SRC "${MISSION_SOURCE_DIR}/tables/${TGT}_${TBLWE}.c")
-            elseif (EXISTS "${MISSION_DEFS}/${TGT}/tables/${TBLWE}.c")
-                set(TBL_SRC "${MISSION_DEFS}/${TGT}/tables/${TBLWE}.c")
-            elseif (EXISTS "${MISSION_DEFS}/tables/${TBLWE}.c")
-                set(TBL_SRC "${MISSION_DEFS}/tables/${TBLWE}.c")
-            elseif (EXISTS "${MISSION_SOURCE_DIR}/tables/${TBLWE}.c")
-                set(TBL_SRC "${MISSION_SOURCE_DIR}/tables/${TBLWE}.c")
-            elseif (IS_ABSOLUTE "${TBL}")
-                set(TBL_SRC "${TBL}")
-            else()
-                set(TBL_SRC "${CMAKE_CURRENT_SOURCE_DIR}/${TBL}")
-            endif()
-
-            if (NOT EXISTS "${TBL_SRC}")
-                message(FATAL_ERROR "ERROR: No source file for table ${TBLWE}")
-            else()
-                message("NOTE: Selected ${TBL_SRC} as source for ${APP_NAME}.${TBLWE} on ${TGT}")
-
-                # NOTE: On newer CMake versions this should become an OBJECT library which makes this simpler.
-                # On older versions one may not reference the TARGET_OBJECTS property from the custom command.
-                # As a workaround this is built into a static library, and then the desired object is extracted
-                # before passing to elf2cfetbl.  It is roundabout but it works.
-                add_library(${TABLE_LIBNAME} STATIC ${TBL_SRC})
-                target_link_libraries(${TABLE_LIBNAME} PRIVATE core_api)
-                if (TARGET ${APP_NAME})
-                    target_include_directories(${TABLE_LIBNAME} PRIVATE $<TARGET_PROPERTY:${APP_NAME},INCLUDE_DIRECTORIES>)
-                    target_compile_definitions(${TABLE_LIBNAME} PRIVATE $<TARGET_PROPERTY:${APP_NAME},COMPILE_DEFINITIONS>)
-                endif()
-
-                # IMPORTANT: This rule assumes that the output filename of elf2cfetbl matches
-                # the input file name but with a different extension (.o -> .tbl)
-                # The actual output filename is embedded in the source file (.c), however
-                # this must match and if it does not the build will break.  That's just the
-                # way it is, because NO make system supports changing rules based on the
-                # current content of a dependency (rightfully so).
-                add_custom_command(
-                    OUTPUT ${TABLE_BINARY}
-                    COMMAND ${CMAKE_COMMAND}
-                        -DCMAKE_AR=${CMAKE_AR}
-                        -DTBLTOOL=${MISSION_BINARY_DIR}/tools/elf2cfetbl/elf2cfetbl
-                        -DLIB=$<TARGET_FILE:${TABLE_LIBNAME}>
-                        -P ${CFE_SOURCE_DIR}/cmake/generate_table.cmake
-                    DEPENDS ${MISSION_BINARY_DIR}/tools/elf2cfetbl/elf2cfetbl ${TABLE_LIBNAME}
-                    WORKING_DIRECTORY ${TABLE_DESTDIR}
-                )
-
-                # Add a custom target to invoke the elf2cfetbl tool to generate the tbl file,
-                # and install that binary file to the staging area.
-                add_custom_target(${TABLE_LIBNAME}_tbl ALL DEPENDS ${TABLE_BINARY})
-                install(FILES ${TABLE_BINARY} DESTINATION ${TGT}/${INSTALL_SUBDIR})
-            endif()
-        endforeach()
     endforeach()
 
 
@@ -513,6 +598,10 @@ endfunction(cfs_app_check_intf)
 #
 function(prepare)
 
+  # "cfetables" is a top level target to build all table files
+  # all generated table files will be added as dependencies to this target
+  add_custom_target(cfetables)
+
   # Choose the configuration file to use for OSAL on this system
   set(OSAL_CONFIGURATION_FILE)
   foreach(CONFIG ${BUILD_CONFIG_${TARGETSYSTEM}} ${OSAL_SYSTEM_OSCONFIG})