Fix memory leak caused by accessing out-of-scope initializer_list

AddressSanitizer reported a memory leak in `expression_definition` due to the
dependency list being stored as a `std::initializer_list`, which points to a
temporary array on the caller’s stack. Once the temporary goes out of scope,
the stored begin/end pointers become invalid, leading to stray reads when
iterating over dependencies.

- Replaced the `std::initializer_list` member with a `std::vector` to ensure
  ownership of the data is maintained
- Introduced `counter_data` classes to distinguish between expression and
  hardware counters at runtime, avoiding memory allocation for both types
  when only one is needed
- Added helper getter functions for easier data access based on counter type
- Enabled ASAN for the unit test executables to improve memory issue detection
  in the future

Author: yahyaA-arm

.clang-tidy

@@ -18,8 +18,7 @@ Checks: >-
   cppcoreguidelines-pro-type-member-init,
   cppcoreguidelines-pro-type-reinterpret-cast
 WarningsAsErrors: '*'
-HeaderFilterRegex: '^.*/hwcpipe2/(device|debug|test)/.*\.hpp$'
-AnalyzeTemporaryDtors: false
+HeaderFilterRegex: '^.*/github/(hwcpipe|test|examples)/.*\.hpp$'
 FormatStyle:     file
 CheckOptions:
   - key:             llvm-else-after-return.WarnOnConditionVariables

.github/workflows/android-clang.yaml

@@ -55,6 +55,6 @@ graphics development or technology please submit them on the [Arm Community grap
 
 - - -
 
-_Copyright © 2023-2024, Arm Limited and contributors. All rights reserved._
+_Copyright © 2023-2025, Arm Limited and contributors. All rights reserved._
 
 [1]: https://community.arm.com/support-forums/f/graphics-gaming-and-vr-forum/

.github/workflows/linux-clang.yaml

@@ -0,0 +1,86 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+
+minimum_pre_commit_version: 2.9.0
+
+exclude: "device/src/uapi/.*"
+repos:
+    # global hooks
+    - repo: https://github.com/pre-commit/pre-commit-hooks
+      rev: v4.4.0
+      hooks:
+          - id: trailing-whitespace
+          - id: end-of-file-fixer
+            exclude: "third_party/.*/vendor/.*"
+          - id: check-ast
+          - id: check-json
+          - id: check-yaml
+            args: [--unsafe]
+          - id: check-added-large-files
+            exclude: "third_party/.*/vendor/.*"
+          - id: check-merge-conflict
+          - id: debug-statements
+          - id: mixed-line-ending
+            exclude: "third_party/.*/vendor/.*"
+    - repo: https://github.com/PeterMosmans/jenkinslint
+      rev: v1.0.0
+      hooks:
+          - id: jenkinslint
+            files: Jenkinsfile
+    - repo: https://github.com/alessandrojcm/commitlint-pre-commit-hook
+      rev: v9.5.0
+      hooks:
+        - id: commitlint
+          stages: [commit-msg]
+          additional_dependencies: ['@commitlint/config-conventional']
+    - repo: https://github.com/pre-commit/mirrors-prettier
+      rev: v2.7.1
+      hooks:
+          - id: prettier
+            types: [markdown]
+    - repo: https://github.com/cheshirekow/cmake-format-precommit
+      rev: v0.6.13
+      hooks:
+        - id: cmake-format
+        - id: cmake-lint
+    - repo: https://github.com/PyCQA/pylint
+      rev: v3.0.0a6
+      hooks:
+        - id: pylint
+          additional_dependencies: &pip-packages
+            - pystache==0.6.0
+            - PyYAML==6.0
+            - types-PyYAML==6.0.7
+            - parameterized==0.8.1
+    - repo: https://github.com/PyCQA/flake8
+      rev: 6.0.0
+      hooks:
+        - id: flake8
+          args: ['--max-line-length=120']
+    - repo: https://github.com/psf/black
+      rev: 23.3.0
+      hooks:
+        - id: black
+    - repo: https://github.com/pre-commit/mirrors-mypy
+      rev: v1.3.0
+      hooks:
+        - id: mypy
+          additional_dependencies: *pip-packages
+    - repo: https://github.com/pre-commit/mirrors-clang-format
+      rev: v16.0.4
+      hooks:
+        - id: clang-format
+    - repo: https://github.com/codespell-project/codespell
+      rev: v2.2.4
+      hooks:
+        - id: codespell
+          exclude: "third_party/.*/vendor/.*"
+    - repo: https://gitlab.gpu.arm.com/pre-commit/copyright.git
+      rev: v1.0.0-alpha.16
+      hooks:
+        - id: copyright
+          exclude: (?x)^(
+            third_party/.*/vendor/.*
+            |test/workload/src/workload_impl.[ch]pp
+            )$
+          types_or: [c, c++, python]

.github/workflows/linux-gcc.yaml

@@ -29,7 +29,7 @@ project(hwcpipe2)
 option(
     HWCPIPE_ENABLE_TESTS
     "If set, build unit tests."
-    OFF
+    ON
 )
 option(HWCPIPE_ENABLE_EXCEPTIONS "If set, c++ exceptions are enabled.")
 option(

README.md

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023-2024 Arm Limited.
+ * Copyright (c) 2023-2025 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  */
@@ -40,6 +40,7 @@ void print_sample_value(const hwcpipe::counter_sample &sample) {
         std::cout << sample.value.float64;
         return;
     default:
+        std::cout << "Unknown";
         return;
     }
 }

backend/.pre-commit-config.yaml

@@ -18,9 +18,14 @@
 #include <cstdint>
 #include <initializer_list>
 #include <system_error>
+#include <vector>
 namespace hwcpipe {
 namespace detail {
 
+struct counter_data {
+    virtual ~counter_data() noexcept = default;
+};
+
 namespace expression {
 /**
  * The expression evaluation context provides an abstraction over some block of
@@ -66,7 +71,7 @@ using evaluator = double (*)(const context &);
  * Holds information about the expression that the sampler will need when
  * registering the counters and evaluating.
  */
-struct expression_definition {
+struct expression_definition : public counter_data {
     /**
      * Pointer to the function that will evaluate the expression and return the
      * calculated result.
@@ -77,18 +82,29 @@ struct expression_definition {
      * be implicitly registered with the sampler so that they can be collected
      * when it is polled.
      */
-    const std::initializer_list<hwcpipe_counter> dependencies;
+    const std::vector<hwcpipe_counter> dependencies;
+
+    expression_definition(evaluator eval, const std::initializer_list<hwcpipe_counter> dependencies)
+        : eval(eval)
+        , dependencies(std::move(dependencies)) {}
 };
 
 } // namespace expression
 /**
  * Structure representing the block type/offset address and shift
  * scaling of a counter within a particular GPU's PMU data.
  */
-struct block_offset {
+struct block_offset : public counter_data {
+    using block_t = hwcpipe::device::hwcnt::block_type;
+
     uint32_t offset;
     uint32_t shift;
-    hwcpipe::device::hwcnt::block_type block_type;
+    block_t block_type;
+
+    block_offset(uint32_t offset, uint32_t shift, block_t block_type)
+        : offset(offset)
+        , shift(shift)
+        , block_type(block_type) {}
 };
 
 /**
@@ -102,24 +118,29 @@ struct block_offset {
 struct counter_definition {
     enum class type { invalid, hardware, expression };
     type tag;
-    union u {
-        block_offset address{};
-        expression::expression_definition expression;
-        explicit u(expression::expression_definition expression)
-            : expression(expression) {}
-        explicit u(block_offset address)
-            : address(address) {}
-    } u;
+    const std::shared_ptr<counter_data> data;
+
+    HWCP_NODISCARD const expression::expression_definition &get_expression() const {
+        assert(tag == type::expression);
+        auto const ptr = std::static_pointer_cast<const expression::expression_definition>(data);
+        return *ptr;
+    }
+
+    HWCP_NODISCARD const block_offset &get_address() const {
+        assert(tag == type::hardware);
+        auto const ptr = std::static_pointer_cast<const block_offset>(data);
+        return *ptr;
+    }
 
     counter_definition()
         : tag(type::invalid)
-        , u(block_offset{0, 0, device::hwcnt::block_type::fe}) {}
+        , data(std::make_shared<block_offset>(0, 0, device::hwcnt::block_type::fe)) {}
     explicit counter_definition(expression::expression_definition expression)
         : tag(type::expression)
-        , u(expression) {}
+        , data(std::make_shared<expression::expression_definition>(expression)) {}
     explicit counter_definition(block_offset address)
         : tag(type::hardware)
-        , u(address) {}
+        , data(std::make_shared<block_offset>(address)) {}
 };
 
 struct hwcpipe_backend_policy {

backend/CMakeLists.txt

@@ -157,15 +157,15 @@ class sampler_config {
 
         switch (definition.tag) {
         case detail::counter_definition::type::hardware: {
-            const auto &address = definition.u.address;
+            const auto &address = definition.get_address();
             counters_.emplace(counter, definition);
 
             backend_config_[address.block_type].enable_map[address.offset] = 1;
             break;
         }
         case detail::counter_definition::type::expression: {
             counters_.emplace(counter, definition);
-            ec = add_expression_depedencies(definition.u.expression);
+            ec = add_expression_depedencies(definition.get_expression());
             if (ec) {
                 return ec;
             }
@@ -621,14 +621,14 @@ class sampler : private detail::expression::context {
                 counter_to_buffer_pos_[counter.counter] = buffer_pos;
                 sample_buffer_.push_back({});
 
-                auto &block_pos_list = counters_by_block_map_[counter.definition.u.address.block_type];
-                block_pos_list.emplace_back(counter.definition.u.address.offset, buffer_pos,
-                                            counter.definition.u.address.shift);
+                auto &address = counter.definition.get_address();
+                auto &block_pos_list = counters_by_block_map_[address.block_type];
+                block_pos_list.emplace_back(address.offset, buffer_pos, address.shift);
                 break;
             }
             case detail::counter_definition::type::expression: {
                 // store the function pointer to run this expression in get_counter_value()
-                counter_to_evaluator_.emplace(counter.counter, counter.definition.u.expression.eval);
+                counter_to_evaluator_.emplace(counter.counter, counter.definition.get_expression().eval);
                 break;
             }
             case detail::counter_definition::type::invalid: