[cker] Fix array-bounds build error: Refactor Shape.h to use C++17 std::variant

This commit improves type-safety and memory management by leveraging modern C++17 features.
- Replace the old union-based storage (_dims and _dims_pointer) with a std::variant that holds either a std::array (for shapes with ≤ 6 dimensions) or a std::vector (for larger shapes)
- Update constructors to initialize and resize dims_ accordingly, ensuring that small shapes use the fixed-size array and larger ones use dynamic allocation
- Implement a custom copy constructor to perform a deep copy based on the current storage type and default the move constructor
- Update various member functions (Dims, SetDim, DimsData, Resize, ReplaceWith, BuildFrom, etc.) to use the new std::variant-based storage
- Minor include reordering and addition of necessary headers (e.g., <array>, <iterator>, <variant>)

ONE-DCO-1.0-Signed-off-by: ragmani <ragmani0216@gmail.com>

Author: ragmani

runtime/compute/cker/include/cker/Shape.h

@@ -19,8 +19,11 @@
 #define __NNFW_CKER_SHAPE_H__
 
 #include <algorithm>
-#include <cstring>
+#include <array>
 #include <cassert>
+#include <cstring>
+#include <iterator>
+#include <variant>
 #include <vector>
 
 namespace nnfw
@@ -35,18 +38,25 @@ class Shape
   // larger shapes are separately allocated.
   static constexpr int kMaxSmallSize = 6;
 
+  // Delete copy assignment operator.
   Shape &operator=(Shape const &) = delete;
 
-  Shape() : _size(0) {}
+  // Default constructor: initializes an empty shape (size = 0) with small storage.
+  Shape() : _size(0), dims_(std::array<int32_t, kMaxSmallSize>{}) {}
 
+  // Constructor that takes a dimension count.
+  // If dimensions_count <= kMaxSmallSize, it uses a fixed-size array.
+  // Otherwise, it uses a dynamic vector.
   explicit Shape(int dimensions_count) : _size(dimensions_count)
   {
-    if (dimensions_count > kMaxSmallSize)
-    {
-      _dims_pointer = new int32_t[dimensions_count];
+    if (dimensions_count <= kMaxSmallSize) {
+      dims_ = std::array<int32_t, kMaxSmallSize>{};
+    } else {
+      dims_ = std::vector<int32_t>(dimensions_count);
     }
   }
 
+  // Constructor that creates a shape of given size and fills all dimensions with "value".
   Shape(int shape_size, int32_t value) : _size(0)
   {
     Resize(shape_size);
@@ -56,136 +66,155 @@ class Shape
     }
   }
 
+  // Constructor that creates a shape from an array of dimension data.
   Shape(int dimensions_count, const int32_t *dims_data) : _size(0)
   {
     ReplaceWith(dimensions_count, dims_data);
   }
 
-  Shape(const std::initializer_list<int> init_list) : _size(0) { BuildFrom(init_list); }
+  // Initializer list constructor.
+  // Marked explicit to avoid unintended overload resolution.
+  Shape(const std::initializer_list<int> init_list) : _size(0)
+  {
+    BuildFrom(init_list);
+  }
 
-  // Avoid using this constructor.  We should be able to delete it when C++17
-  // rolls out.
-  Shape(Shape const &other) : _size(other.DimensionsCount())
+  // Copy constructor
+  Shape(const Shape &other) : _size(other._size)
   {
-    if (_size > kMaxSmallSize)
-    {
-      _dims_pointer = new int32_t[_size];
+    if (_size <= kMaxSmallSize) {
+      // When the number of dimensions is small, copy the fixed array.
+      dims_ = std::get<std::array<int32_t, kMaxSmallSize>>(other.dims_);
+    } else {
+      // Otherwise, copy the dynamically allocated vector.
+      dims_ = std::get<std::vector<int32_t>>(other.dims_);
     }
-    std::memcpy(DimsData(), other.DimsData(), sizeof(int32_t) * _size);
   }
+  Shape(Shape &&other) = default;
 
   bool operator==(const Shape &comp) const
   {
     return this->_size == comp._size &&
            std::memcmp(DimsData(), comp.DimsData(), _size * sizeof(int32_t)) == 0;
   }
 
-  ~Shape()
-  {
-    if (_size > kMaxSmallSize)
-    {
-      delete[] _dims_pointer;
-    }
-  }
+  ~Shape() = default;
 
+  // Returns the number of dimensions.
   inline int32_t DimensionsCount() const { return _size; }
+
+  // Returns the dimension size at index i.
   inline int32_t Dims(int i) const
   {
-    assert(i >= 0);
-    assert(i < _size);
-    return _size > kMaxSmallSize ? _dims_pointer[i] : _dims[i];
+    assert(i >= 0 && i < _size);
+    if (_size <= kMaxSmallSize) {
+      return std::get<std::array<int32_t, kMaxSmallSize>>(dims_)[i];
+    } else {
+      return std::get<std::vector<int32_t>>(dims_)[i];
+    }
   }
+
+  // Sets the dimension at index i.
   inline void SetDim(int i, int32_t val)
   {
-    assert(i >= 0);
-    assert(i < _size);
-    if (_size > kMaxSmallSize)
-    {
-      _dims_pointer[i] = val;
+    assert(i >= 0 && i < _size);
+    if (_size <= kMaxSmallSize) {
+      std::get<std::array<int32_t, kMaxSmallSize>>(dims_)[i] = val;
+    } else {
+      std::get<std::vector<int32_t>>(dims_)[i] = val;
     }
-    else
-    {
-      _dims[i] = val;
+  }
+
+  // Returns a pointer to the dimension data (mutable).
+  inline int32_t* DimsData()
+  {
+    if (_size <= kMaxSmallSize) {
+      return std::get<std::array<int32_t, kMaxSmallSize>>(dims_).data();
+    } else {
+      return std::get<std::vector<int32_t>>(dims_).data();
     }
   }
 
-  inline int32_t *DimsData() { return _size > kMaxSmallSize ? _dims_pointer : _dims; }
-  inline const int32_t *DimsData() const { return _size > kMaxSmallSize ? _dims_pointer : _dims; }
-  // The caller must ensure that the shape is no bigger than 6D.
-  inline const int32_t *DimsDataUpTo6D() const { return _dims; }
+  // Returns a pointer to the dimension data (const).
+  inline const int32_t* DimsData() const
+  {
+    if (_size <= kMaxSmallSize) {
+      return std::get<std::array<int32_t, kMaxSmallSize>>(dims_).data();
+    } else {
+      return std::get<std::vector<int32_t>>(dims_).data();
+    }
+  }
 
+  // The caller must ensure that the shape is no larger than 6D.
+  inline const int32_t* DimsDataUpTo6D() const {
+    return std::get<std::array<int32_t, kMaxSmallSize>>(dims_).data();
+  }
+
+  // Resizes the shape to dimensions_count.
   inline void Resize(int dimensions_count)
   {
-    if (_size > kMaxSmallSize)
-    {
-      delete[] _dims_pointer;
-    }
     _size = dimensions_count;
-    if (dimensions_count > kMaxSmallSize)
-    {
-      _dims_pointer = new int32_t[dimensions_count];
+    if (dimensions_count <= kMaxSmallSize) {
+      dims_ = std::array<int32_t, kMaxSmallSize>{};
+    } else {
+      dims_ = std::vector<int32_t>(dimensions_count);
     }
   }
 
+  // Replaces the current shape with a new one defined by dimensions_count and dims_data.
   inline void ReplaceWith(int dimensions_count, const int32_t *dims_data)
   {
     Resize(dimensions_count);
-    int32_t *dst_dims = DimsData();
-    std::memcpy(dst_dims, dims_data, dimensions_count * sizeof(int32_t));
+    std::memcpy(DimsData(), dims_data, dimensions_count * sizeof(int32_t));
   }
 
+  // Replaces the current shape with another shape.
   inline void ReplaceWith(const Shape &other)
   {
     ReplaceWith(other.DimensionsCount(), other.DimsData());
   }
 
+  // Replaces the current shape with another shape using move semantics.
   inline void ReplaceWith(Shape &&other)
   {
-    Resize(0);
     std::swap(_size, other._size);
-    if (_size <= kMaxSmallSize)
-      std::copy(other._dims, other._dims + kMaxSmallSize, _dims);
-    else
-      _dims_pointer = other._dims_pointer;
+    dims_ = std::move(other.dims_);
   }
 
-  template <typename T> inline void BuildFrom(const T &src_iterable)
+  // Builds the shape from an iterable sequence.
+  template <typename Iterable>
+  inline void BuildFrom(const Iterable &src_iterable)
   {
-    const int dimensions_count = std::distance(src_iterable.begin(), src_iterable.end());
+    const int dimensions_count = static_cast<int>(std::distance(src_iterable.begin(), src_iterable.end()));
     Resize(dimensions_count);
-    int32_t *data = DimsData();
-    for (auto &&it : src_iterable)
+    int32_t* data = DimsData();
+    for (auto it = src_iterable.begin(); it != src_iterable.end(); ++it)
     {
-      *data = it;
-      ++data;
+      *data++ = static_cast<int32_t>(*it);
     }
   }
 
-  // This will probably be factored out. Old code made substantial use of 4-D
-  // shapes, and so this function is used to extend smaller shapes. Note that
-  // (a) as Dims<4>-dependent code is eliminated, the reliance on this should be
-  // reduced, and (b) some kernels are stricly 4-D, but then the shapes of their
-  // inputs should already be 4-D, so this function should not be needed.
+  // Returns the total count of elements, that is the size when flattened into a
+  // vector.
   inline static Shape ExtendedShape(int new_shape_size, const Shape &shape)
   {
     return Shape(new_shape_size, shape, 1);
   }
 
+  // Overload for initializer list building.
   inline void BuildFrom(const std::initializer_list<int> init_list)
   {
     BuildFrom<const std::initializer_list<int>>(init_list);
   }
 
-  // Returns the total count of elements, that is the size when flattened into a
-  // vector.
+  // Returns the total count of elements (flattened size).
   inline int FlatSize() const
   {
     int buffer_size = 1;
-    const int *dims_data = DimsData();
+    const int* dims_data = DimsData();
     for (int i = 0; i < _size; i++)
     {
-      const int dim = dims_data[i];
-      buffer_size *= dim;
+      buffer_size *= dims_data[i];
     }
     return buffer_size;
   }
@@ -206,17 +235,17 @@ class Shape
     {
       SetDim(i, pad_value);
     }
-    std::memcpy(DimsData() + size_increase, shape.DimsData(),
-                sizeof(int32_t) * shape.DimensionsCount());
+    std::memcpy(DimsData() + size_increase, shape.DimsData(), sizeof(int32_t) * shape.DimensionsCount());
   }
 
   int32_t _size;
-  union {
-    int32_t _dims[kMaxSmallSize];
-    int32_t *_dims_pointer{nullptr};
-  };
+  // Internal storage: use std::array for shapes with dimensions up to kMaxSmallSize,
+  // and std::vector for larger shapes.
+  std::variant<std::array<int32_t, kMaxSmallSize>, std::vector<int32_t>> dims_;
 };
 
+// Utility functions below.
+
 inline int MatchingDim(const Shape &shape1, int index1, [[maybe_unused]] const Shape &shape2,
                        [[maybe_unused]] int index2)
 {
@@ -232,7 +261,10 @@ int MatchingDim(const Shape &shape1, int index1, [[maybe_unused]] const Shape &s
   return MatchingDim(shape1, index1, args...);
 }
 
-inline Shape GetShape(const std::vector<int32_t> &data) { return Shape(data.size(), data.data()); }
+inline Shape GetShape(const std::vector<int32_t> &data)
+{
+  return Shape(static_cast<int>(data.size()), data.data());
+}
 
 inline int Offset(const Shape &shape, int i0, int i1, int i2, int i3)
 {
@@ -278,8 +310,7 @@ inline int FlatSizeSkipDim(const Shape &shape, int skip_dim)
   return flat_size;
 }
 
-// Flat size calculation, checking that dimensions match with one or more other
-// arrays.
+// Flat size calculation, checking that dimensions match with one or more other shapes.
 template <typename... Ts> inline bool checkMatching(const Shape &shape, Ts... check_shapes)
 {
   auto match = [&shape](const Shape &s) -> bool {

runtime/compute/cker/include/cker/operation/Einsum.h

@@ -871,7 +871,7 @@ class Einsum
     Tensor rhs;
     reshapeToRank3(inputs[1], bcast.y_batch_size(), &rhs);
     Shape old_output_shape = bcast.output_batch_shape();
-    Shape output_shape(old_output_shape.DimensionsCount() + inputs.size());
+    Shape output_shape(static_cast<int>(old_output_shape.DimensionsCount() + inputs.size()));
     for (int i = 0; i < old_output_shape.DimensionsCount(); i++)
     {
       output_shape.SetDim(i, old_output_shape.Dims(i));