Merge PR #172 from tudasc/devel

Author: ahueck

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(typeart
-  VERSION 2.0
+  VERSION 2.1
   HOMEPAGE_URL https://github.com/tudasc/TypeART
   DESCRIPTION "LLVM-based type and memory allocation tracking sanitizer"
 )

README.md

@@ -62,7 +62,7 @@ its [project page](https://itc.rwth-aachen.de/must/).
 
 Using TypeART involves two phases:
 
-1. Compilation: Compile your code with Clang/LLVM (version 14) using the TypeART LLVM pass plugin. The plugin (1) serializes static type information to a file and (2) instruments relevant allocations. See [Section 1.1](#11-compiling-a-target-code).
+1. Compilation: Compile your code with Clang/LLVM using the TypeART LLVM pass plugin. The plugin (1) serializes static type information to a file and (2) instruments relevant allocations. See [Section 1.1](#11-compiling-a-target-code).
 2. Execution: Run the instrumented program with a TypeART runtime client, which uses the callback data to perform analysis facilitating the static type information. See [Section 1.2](#12-executing-an-instrumented-target-code).
 
 ### 1.1 Compiling a target code
@@ -279,7 +279,7 @@ To compile and run the demo targets:
 
 ## 2. Building TypeART
 
-TypeART supports LLVM version 14 and 18 and CMake version >= 3.20.
+TypeART supports LLVM version 14, 18 and 19, and CMake version >= 3.20.
 
 ### 2.1 Optional software requirements
 
@@ -378,7 +378,7 @@ Example using CMake [FetchContent](https://cmake.org/cmake/help/latest/module/Fe
 FetchContent_Declare(
   typeart
   GIT_REPOSITORY https://github.com/tudasc/TypeART
-  GIT_TAG v1.9.1
+  GIT_TAG v2.1
   GIT_SHALLOW 1
 )
 FetchContent_MakeAvailable(typeart)

externals/dimeta/CMakeLists.txt

@@ -1,7 +1,7 @@
 FetchContent_Declare(
   llvm-dimeta
   GIT_REPOSITORY https://github.com/ahueck/llvm-dimeta
-  GIT_TAG v0.2.0
+  GIT_TAG v0.3.0
   GIT_SHALLOW 1
 )
 

lib/passes/typegen/dimeta/DimetaTypeGen.cpp

@@ -231,6 +231,11 @@ std::optional<typeart_builtin_type> get_builtin_typeid(const dimeta::QualifiedFu
   const auto extent   = type.type.extent;
   const auto encoding = type.type.encoding;
 
+  if (type.type.name == "wchar_t" || type.typedef_name == "wchar_t") {
+    // Clang 18 typedef's wchar_t
+    return TYPEART_WCHAR;
+  }
+
   switch (encoding) {
     case FundamentalType::Encoding::kVtablePtr:
       return TYPEART_VTABLE_POINTER;

lib/runtime/AccessCountPrinter.h

@@ -54,30 +54,33 @@ void serialize(const Recorder& r, std::ostringstream& buf) {
   if constexpr (std::is_same_v<Recorder, NoneRecorder>) {
     return;
   } else {
-    const auto memory_use = memory::estimate(r.getMaxStackAllocs(), r.getMaxHeapAllocs(), r.getGlobalAllocs());
-
-    Table t("Alloc Stats from softcounters");
-    t.wrap_length_ = true;
-    t.put(Row::make("Total heap", r.getHeapAllocs(), r.getHeapArray()));
-    t.put(Row::make("Total stack", r.getStackAllocs(), r.getStackArray()));
-    t.put(Row::make("Total global", r.getGlobalAllocs(), r.getGlobalArray()));
-    t.put(Row::make("Max. Heap Allocs", r.getMaxHeapAllocs()));
-    t.put(Row::make("Max. Stack Allocs", r.getMaxStackAllocs()));
-    t.put(Row::make("Addresses checked", r.getAddrChecked()));
-    t.put(Row::make("Distinct Addresses checked", r.getSeen().size()));
-    t.put(Row::make("Addresses re-used", r.getAddrReuses()));
-    t.put(Row::make("Addresses missed", r.getAddrMissing()));
-    t.put(Row::make("Distinct Addresses missed", r.getMissing().size()));
-    t.put(Row::make("Total free heap", r.getHeapAllocsFree(), r.getHeapArrayFree()));
-    t.put(Row::make("Total free stack", r.getStackAllocsFree(), r.getStackArrayFree()));
-    t.put(Row::make("OMP Stack/Heap/Free", r.getOmpStackCalls(), r.getOmpHeapCalls(), r.getOmpFreeCalls()));
-    t.put(Row::make("Null/Zero/NullZero Addr", r.getNullAlloc(), r.getZeroAlloc(), r.getNullAndZeroAlloc()));
-    t.put(Row::make("User-def. types", r.getNumUDefTypes()));
-    t.put(Row::make("Estimated memory use (KiB)", size_t(std::round(memory_use.map + memory_use.stack))));
-    t.put(Row::make("Bytes per node map/stack", memory::MemOverhead::perNodeSizeMap,
-                    memory::MemOverhead::perNodeSizeStack));
-
-    t.print(buf);
+    // const auto memory_use = memory::estimate(r.getMaxStackAllocs(), r.getMaxHeapAllocs(), r.getGlobalAllocs());
+
+    Table overview_table("Alloc Stats from softcounters");
+    overview_table.wrap_length_ = true;
+    overview_table.put(Row::make("Total heap", r.getHeapAllocs(), r.getHeapArray()));
+    overview_table.put(Row::make("Total stack", r.getStackAllocs(), r.getStackArray()));
+    overview_table.put(Row::make("Total global", r.getGlobalAllocs(), r.getGlobalArray()));
+    overview_table.put(Row::make("Max. heap", r.getMaxHeapAllocs()));
+    overview_table.put(Row::make("Max. stack", r.getMaxStackAllocs()));
+    overview_table.put(Row::make("Addresses checked", r.getAddrChecked()));
+    overview_table.put(Row::make("Distinct addresses checked", r.getSeen().size()));
+    overview_table.put(Row::make("Addresses re-used", r.getAddrReuses()));
+    overview_table.put(Row::make("Addresses missed", r.getAddrMissing()));
+    overview_table.put(Row::make("Distinct addresses missed", r.getMissing().size()));
+    overview_table.put(Row::make("Total free heap", r.getHeapAllocsFree(), r.getHeapArrayFree()));
+    overview_table.put(Row::make("Total free stack", r.getStackAllocsFree(), r.getStackArrayFree()));
+    overview_table.put(
+        Row::make("OMP stack/heap/free", r.getOmpStackCalls(), r.getOmpHeapCalls(), r.getOmpFreeCalls()));
+    overview_table.put(
+        Row::make("Null/Zero/NullZero addr", r.getNullAlloc(), r.getZeroAlloc(), r.getNullAndZeroAlloc()));
+    overview_table.put(Row::make("User-def. types", r.getNumUDefTypes()));
+    overview_table.put(Row::make("Distinct query types", r.getTypeQuery().size()));
+    // t.put(Row::make("Estimated memory use (KiB)", size_t(std::round(memory_use.map + memory_use.stack))));
+    // t.put(Row::make("Bytes per node map/stack", memory::MemOverhead::perNodeSizeMap,
+    // memory::MemOverhead::perNodeSizeStack));
+
+    overview_table.print(buf);
 
     std::set<int> type_id_set;
     const auto fill_set = [&type_id_set](const auto& map) {
@@ -98,27 +101,52 @@ void serialize(const Recorder& r, std::ostringstream& buf) {
       }
       return 0LL;
     };
-
-    Table type_table("Allocation type detail (heap, stack, global)");
-    type_table.table_header_ = '#';
-    for (auto type_id : type_id_set) {
-      type_table.put(Row::make(std::to_string(type_id), count(r.getHeapAlloc(), type_id),
-                               count(r.getStackAlloc(), type_id), count(r.getGlobalAlloc(), type_id),
-                               typeart_get_type_name(type_id)));
+    {
+      Table type_table("Allocation type detail (heap, stack, global)");
+      type_table.table_header_ = '#';
+      for (auto type_id : type_id_set) {
+        type_table.put(Row::make(std::to_string(type_id), count(r.getHeapAlloc(), type_id),
+                                 count(r.getStackAlloc(), type_id), count(r.getGlobalAlloc(), type_id),
+                                 typeart_get_type_name(type_id)));
+      }
+      type_table.print(buf);
     }
+    {
+      Table type_table_free("Free allocation type detail (heap, stack)");
+      type_table_free.table_header_ = '#';
+      for (auto type_id : type_id_set) {
+        const auto count_type_h = count(r.getHeapFree(), type_id);
+        const auto count_type_s = count(r.getStackFree(), type_id);
+        if (count_type_h == 0 && count_type_s == 0) {
+          continue;
+        }
+        type_table_free.put(
+            Row::make(std::to_string(type_id), count_type_h, count_type_s, typeart_get_type_name(type_id)));
+      }
 
-    type_table.print(buf);
-
-    Table type_table_free("Free allocation type detail (heap, stack)");
-    type_table_free.table_header_ = '#';
-    for (auto type_id : type_id_set) {
-      type_table_free.put(Row::make(std::to_string(type_id), count(r.getHeapFree(), type_id),
-                                    count(r.getStackFree(), type_id), typeart_get_type_name(type_id)));
+      type_table_free.print(buf);
     }
+    {
+      Table type_table_query("Query type detail");
+      type_table_query.table_header_ = '#';
+      const auto& query_map          = r.getTypeQuery();
+      std::set<int> query_id_set;
+      for (const auto& [key, val] : query_map) {
+        query_id_set.insert(key);
+      }
+      for (auto query_type_id : query_id_set) {
+        const auto count_type = count(query_map, query_type_id);
+        type_table_query.put(
+            Row::make(std::to_string(query_type_id), count_type, typeart_get_type_name(query_type_id)));
+      }
 
-    type_table_free.print(buf);
+      type_table_query.print(buf);
+    }
 
     const auto numThreads = r.getNumThreads();
+    if (numThreads < 2) {
+      return;
+    }
     std::stringstream ss;
     ss << "Per-thread counter values (" << numThreads << " threads)";
     Table thread_table(ss.str());

lib/runtime/AccessCounter.h

@@ -193,6 +193,11 @@ class AccessRecorder {
 
   ~AccessRecorder() = default;
 
+  inline void incTypeQuery(int type_id) {
+    std::lock_guard lock(typeQueryMutex);
+    ++typeQuery[type_id];
+  }
+
   inline void incHeapAlloc(int typeId, size_t count) {
     ++curHeapAllocs;
 
@@ -446,6 +451,10 @@ class AccessRecorder {
     std::shared_lock slock(seenMutex);
     return seen;
   }
+  TypeCountMap getTypeQuery() const {
+    std::shared_lock slock(typeQueryMutex);
+    return typeQuery;
+  }
   TypeCountMap getStackAlloc() const {
     std::shared_lock slock(stackAllocMutex);
     return stackAlloc;
@@ -524,13 +533,18 @@ class AccessRecorder {
 
   TypeCountMap heapFree;
   mutable MutexT heapFreeMutex;
+
+  TypeCountMap typeQuery;
+  mutable MutexT typeQueryMutex;
 };
 
 /**
  * Used for no-operations in counter methods when not using softcounters.
  */
 class NoneRecorder {
  public:
+  [[maybe_unused]] inline void incTypeQuery(int) {
+  }
   [[maybe_unused]] inline void incHeapAlloc(int, size_t) {
   }
   [[maybe_unused]] inline void incStackAlloc(int, size_t) {

lib/runtime/RuntimeInterface.h

@@ -59,6 +59,12 @@ typedef struct typeart_type_info_t {
   typeart_base_type_info base_type_info;  // API dependent
 } typeart_type_info;
 
+typedef struct typeart_source_loc_t {
+  char* file;
+  char* function;
+  unsigned line;
+} typeart_source_location;
+
 /**
  * Determines the type and array element count at the given address.
  * For nested types with classes/structs, the containing type is resolved recursively, until an exact with the address
@@ -194,16 +200,25 @@ typeart_status typeart_get_return_address(const void* addr, const void** return_
  * caller.
  *
  * \param[in] addr The address.
- * \param[out] file The file where the address was created at.
- * \param[out] function The function where the address was created at.
- * \param[out] line The approximate line where the address was created at.
+ * \param[out] source_loc The file/function/line where the address was created at.
  *
  * \return One of the following status codes:
  *  - TYPEART_OK: Success.
  *  - TYPEART_UNKNOWN_ADDRESS: The given address is either not allocated, or was not recorded by the runtime.
  *  - TYPEART_ERROR: Memory could not be allocated.
  */
-typeart_status typeart_get_source_location(const void* addr, char** file, char** function, char** line);
+typeart_status typeart_get_source_location(const void* addr, typeart_source_location* source_loc);
+
+/**
+ * Free previously allocated typeart_source_location.
+ *
+ * \param[in] source_loc The file/function/line where the address was created at.
+ *
+ * \return One of the following status codes:
+ *  - TYPEART_OK: Success.
+ *  - TYPEART_ERROR: source_loc was NULL.
+ */
+typeart_status typeart_free_source_location(typeart_source_location* source_loc);
 
 /**
  * Given a type ID, this function provides information about the corresponding struct type.