[CGFCOLLECTOR] Adding Fortran call graph collector

.github/workflows/mcg-ci.yml

@@ -196,4 +196,10 @@ jobs:
         with:
           image: metacg-devel:latest
           run: /opt/metacg/build/tools/cgdiff/test/unit/cgdifftests
-
+      - name: Run cgfcollector tests
+        uses: maus007/docker-run-action-fork@207a4e2a8ebf7e4b985656ba990b1e53715dce2a
+        with:
+          image: metacg-devel:latest
+          run: |
+            cd /opt/metacg/build/cgfcollector
+            ctest . --verbose

.gitignore

@@ -17,3 +17,6 @@ cmake-build*/
 spack.yaml
 spack.lock
 .spack-env/
+
+cgfcollector/test/multi/cmake_base.txt
+cgfcollector/test/multi/make_base

CMakeLists.txt

@@ -213,3 +213,15 @@ if(METACG_BUILD_PYMETACG)
 endif()
 
 add_subdirectory(utils)
+
+# Build fortran collector
+option(
+  METACG_BUILD_CGFCOLLECTOR
+  "On or off"
+  OFF
+)
+
+if(METACG_BUILD_CGFCOLLECTOR)
+  include(FlangLLVM)
+  add_subdirectory(cgfcollector)
+endif()

cgfcollector/CMakeLists.txt

@@ -0,0 +1,119 @@
+set(PROJECT_NAME cgfcollector)
+set(TARGETS_EXPORT_NAME ${PROJECT_NAME}-target)
+
+file(
+  GLOB
+  CGFCOLLECTOR_SOURCES
+  src/*.cpp
+)
+
+add_library(${PROJECT_NAME} SHARED ${CGFCOLLECTOR_SOURCES})
+add_flang(${PROJECT_NAME})
+add_metacg(${PROJECT_NAME})
+add_spdlog_libraries(${PROJECT_NAME})
+
+target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+install(
+  TARGETS ${PROJECT_NAME}
+  EXPORT ${TARGETS_EXPORT_NAME}
+  LIBRARY DESTINATION lib
+  ARCHIVE DESTINATION lib
+)
+
+configure_package_config_file(
+  ${METACG_Directory}/cmake/Config.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
+  INSTALL_DESTINATION lib/cmake
+)
+
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake DESTINATION lib/cmake)
+
+# generate wrapper scripts
+
+function(
+  configure_file_and_install
+  TEMPLATE
+  OUTPUT_BASENAME
+  DESTINATION
+)
+  set(BUILD_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${OUTPUT_BASENAME}")
+  set(INSTALL_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${OUTPUT_BASENAME}.install")
+
+  # build-time values for development
+  set(CGFCOLLECTOR_FILE_NAME_LIB "${CMAKE_CURRENT_BINARY_DIR}/lib${PROJECT_NAME}.so")
+  set(CGFCOLLECTOR_CGDIFF_BIN "${CMAKE_BINARY_DIR}/tools/cgdiff/cgdiff")
+  set(CGFCOLLECTOR_WRAPPER "${CMAKE_CURRENT_BINARY_DIR}/cgfcollector_wrapper.sh")
+  set(CGFCOLLECTOR_TEST_CASES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/test")
+  set(CGMERGE2_BIN "${CMAKE_BINARY_DIR}/tools/cgmerge2/cgmerge2")
+
+  configure_file(
+    "${TEMPLATE}"
+    "${BUILD_OUTPUT}"
+    @ONLY
+  )
+
+  if(DESTINATION
+     STREQUAL
+     ""
+  )
+    return()
+  endif()
+
+  # install-time values
+  set(CGFCOLLECTOR_FILE_NAME_LIB "${CMAKE_INSTALL_PREFIX}/lib/lib${PROJECT_NAME}.so")
+
+  configure_file(
+    "${TEMPLATE}"
+    "${INSTALL_OUTPUT}"
+    @ONLY
+  )
+
+  install(
+    PROGRAMS "${INSTALL_OUTPUT}"
+    DESTINATION "${DESTINATION}"
+    RENAME "${OUTPUT_BASENAME}"
+  )
+endfunction()
+
+configure_file_and_install(
+  "${CMAKE_CURRENT_SOURCE_DIR}/tools/cgfcollector_wrapper.sh.in"
+  "cgfcollector_wrapper.sh"
+  "bin"
+)
+
+configure_file_and_install(
+  "${CMAKE_CURRENT_SOURCE_DIR}/tools/cgfcollector_comp_wrapper.sh.in"
+  "cgfcollector_comp_wrapper.sh"
+  "bin"
+)
+
+configure_file_and_install(
+  "${CMAKE_CURRENT_SOURCE_DIR}/tools/test_runner.sh.in"
+  "test_runner.sh"
+  ""
+)
+
+configure_file_and_install(
+  "${CMAKE_CURRENT_SOURCE_DIR}/test/multi/cmake_base.txt.in"
+  "cmake_base.txt"
+  ""
+)
+file(
+  RENAME
+  "${CMAKE_CURRENT_BINARY_DIR}/cmake_base.txt"
+  "${CMAKE_CURRENT_SOURCE_DIR}/test/multi/cmake_base.txt"
+)
+
+configure_file_and_install(
+  "${CMAKE_CURRENT_SOURCE_DIR}/test/multi/make_base.in"
+  "make_base"
+  ""
+)
+file(
+  RENAME
+  "${CMAKE_CURRENT_BINARY_DIR}/make_base"
+  "${CMAKE_CURRENT_SOURCE_DIR}/test/multi/make_base"
+)
+
+# tests
+add_test(NAME cgfcollector_tests COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test_runner.sh)

cgfcollector/README.md

@@ -0,0 +1,87 @@
+# CG Fortran collector
+
+Fortran call graph generation tool for MetaCG. This tool is implemented as a
+Flang plugin and generates a call graph from source-level.
+
+## Usage
+
+For single file projects or projects not using modules use:
+
+```sh
+cgfcollector_wrapper.sh [options] <source file/s>
+```
+
+For any other projects you need a build system. For this we provide another
+script that acts as the normal Flang compiler but also produces a call graph.
+[More info below](#generate-a-call-graph).
+
+```sh
+cgfcollector_comp_wrapper.sh <source file/s>
+```
+
+You can also run the plugin directly with Flang:
+
+```sh
+flang -fc1 -load "libcgfcollector.so" -plugin "genCG" [options]
+```
+
+Available options:
+
+- `--dot`: Additionally generate a DOT file. This is mostly used for debugging.
+- `--no-rename`: Do not rename the output file to `.json`.
+- `--verbose`: Print additional information during the generation process.
+
+Additionally these other tools are included:
+
+- `cgfcollector_wrapper.sh`: Convenience wrapper to run parse plugin.
+- `cgfcollector_comp_wrapper.sh`: Acts like a normal Flang compiler but also generates a call graph.
+- `test_runner.sh`: Run tests.
+
+## How to build
+
+To build the cgfcollector the option `METACG_BUILD_CGFCOLLECTOR` must be set to
+`ON`.
+
+## Generate a call graph
+
+### from a CMake project
+
+Paste this into your CMakeLists.txt.
+
+```
+set(CMAKE_Fortran_COMPILER <path to cgfcollector_wrapper.sh>)
+set(CMAKE_Fortran_FLAGS "")
+set(CMAKE_Fortran_COMPILE_OBJECT "<CMAKE_Fortran_COMPILER> --dot <DEFINES> <INCLUDES> <FLAGS> <SOURCE> -o <OBJECT>")
+set(CMAKE_Fortran_LINK_EXECUTABLE "<path to cgmerge2> <TARGET> <OBJECTS>")
+set(CMAKE_EXECUTABLE_SUFFIX .json)
+```
+
+This will hook into the CMake build process and generate a call graph instead of
+an executable.
+
+An example can be found in `test/multi/deps`.
+
+### from other projects
+
+Use `cgfcollector_comp_wrapper.sh` or `cgfcollector_wrapper.sh` to hook into the
+build process of your favorite tool and use the `cgmerge2` utility to merge the
+partial generated call graphs.
+
+An example can be found in `test/multi/fortdepend_deps`. This example uses
+fortdepend to generate a module dependency list. If your build system already
+generates such a list and executes the compiler on the files in the correct order
+you probably don't need this.
+
+## Running test
+
+Run `test_runner.sh`
+
+NOTE: The test `test/multi/fortdepend_deps` has a dependency on [fortdepend](https://fortdepend.readthedocs.io/en/latest/)
+
+## Debugging
+
+### print parse tree
+
+```sh
+flang-new -fc1 -fdebug-dump-parse-tree file.f90
+```

cgfcollector/include/Edge.h

@@ -0,0 +1,82 @@
+/**
+ * File: Edge.h
+ * License: Part of the MetaCG project. Licensed under BSD 3 clause license. See LICENSE.txt file at
+ * https://github.com/tudasc/metacg/LICENSE.txt
+ */
+
+#pragma once
+
+#include "FortranUtil.h"
+#include "Type.h"
+
+#include <LoggerUtil.h>
+#include <flang/Parser/parse-tree.h>
+#include <flang/Semantics/symbol.h>
+#include <string>
+#include <vector>
+
+namespace metacg::cgfcollector {
+
+struct PotentialFinalizer;
+
+struct Edge {
+  std::string caller;
+  std::string callee;
+
+  Edge(std::string caller, std::string callee) : caller(std::move(caller)), callee(std::move(callee)) {}
+
+  bool operator==(const Edge& other) const { return caller == other.caller && callee == other.callee; }
+  bool operator<(const Edge& other) const {
+    return caller < other.caller || (caller == other.caller && callee < other.callee);
+  }
+};  // namespace metacg::cgfcollector
+
+struct EdgeSymbol {
+  const Fortran::semantics::Symbol* caller;
+  const Fortran::semantics::Symbol* callee;
+
+  EdgeSymbol(const Fortran::semantics::Symbol* caller, const Fortran::semantics::Symbol* callee)
+      : caller(caller), callee(callee) {}
+
+  bool operator==(const EdgeSymbol& other) const { return caller == other.caller && callee == other.callee; }
+  bool operator<(const EdgeSymbol& other) const {
+    return caller < other.caller || (caller == other.caller && callee < other.callee);
+  }
+};
+
+struct EdgeManager {
+  std::vector<Edge>& edges;
+
+  EdgeManager(std::vector<Edge>& edges) : edges(edges) {}
+
+  void addEdge(const EdgeSymbol& e);
+  void addEdge(const Fortran::semantics::Symbol* caller, const Fortran::semantics::Symbol* callee);
+  void addEdge(const Edge& e);
+  void addEdge(const std::string& caller, const std::string& callee);
+  void addEdges(const std::vector<Edge>& newEdges);
+  void addEdges(const std::vector<EdgeSymbol>& newEdges);
+
+  /**
+   * @brief For a given symbol, returns a list of edges from the current function to all finalizers of that type.
+   *
+   * @param types
+   * @param currentFunctionSymbol
+   * @param symbol
+   */
+  [[nodiscard]] std::vector<EdgeSymbol> getEdgesForFinalizers(const std::vector<Type>& types,
+                                                              const Fortran::semantics::Symbol* currentFunctionSymbol,
+                                                              const Fortran::semantics::Symbol* symbol);
+  /**
+   * @brief Calls getEdgesForFinalizers and adds them to the edges vector.
+   *
+   * @param types
+   * @param currentFunctionSymbol
+   * @param symbol
+   */
+  void addEdgesForFinalizers(const std::vector<Type>& types, const Fortran::semantics::Symbol* currentFunctionSymbol,
+                             const Fortran::semantics::Symbol* symbol);
+
+  void addEdgesForFinalizers(const PotentialFinalizer& e);
+};
+
+}  // namespace metacg::cgfcollector