From 3f8861dc42d20e8c67fe60dd6ea34dbe57aeb4fc Mon Sep 17 00:00:00 2001
From: Fabian Kosmale <fabian.kosmale@qt.io>
Date: Thu, 5 Oct 2023 16:58:33 +0200
Subject: qv4mm: Document and extend allocManaged overload set

Add some helper overloads to centralize the sizeof computation.
Add a doc note about the various variants of allocManaged, including a
note why we even need the size parameter.

Change-Id: I4e0c485217e87c339a7433c306cb05d6614d30e1
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
---
 src/qml/memory/qv4mm_p.h | 31 ++++++++++++++++++++++++++++++-
 1 file changed, 30 insertions(+), 1 deletion(-)

(limited to 'src/qml/memory/qv4mm_p.h')

diff --git a/src/qml/memory/qv4mm_p.h b/src/qml/memory/qv4mm_p.h
index 378b36369d..3a05bca536 100644
--- a/src/qml/memory/qv4mm_p.h
+++ b/src/qml/memory/qv4mm_p.h
@@ -117,6 +117,14 @@ public:
     constexpr static inline std::size_t align(std::size_t size)
     { return (size + Chunk::SlotSize - 1) & ~(Chunk::SlotSize - 1); }
 
+    /* NOTE: allocManaged comes in various overloads. If size is not passed explicitly
+       sizeof(ManagedType::Data) is used for size. However, there are quite a few cases
+       where we allocate more than sizeof(ManagedType::Data); that's generally the case
+       when the Object has a ValueArray member.
+       If no internal class pointer is provided, ManagedType::defaultInternalClass(engine)
+       will be used as the internal class.
+    */
+
     template<typename ManagedType>
     inline typename ManagedType::Data *allocManaged(std::size_t size, Heap::InternalClass *ic)
     {
@@ -129,12 +137,24 @@ public:
         return d;
     }
 
+    template<typename ManagedType>
+    inline typename ManagedType::Data *allocManaged(Heap::InternalClass *ic)
+    {
+        return allocManaged<ManagedType>(sizeof(typename ManagedType::Data), ic);
+    }
+
     template<typename ManagedType>
     inline typename ManagedType::Data *allocManaged(std::size_t size, InternalClass *ic)
     {
         return allocManaged<ManagedType>(size, ic->d());
     }
 
+    template<typename ManagedType>
+    inline typename ManagedType::Data *allocManaged(InternalClass *ic)
+    {
+        return allocManaged<ManagedType>(sizeof(typename ManagedType::Data), ic);
+    }
+
     template<typename ManagedType>
     inline typename ManagedType::Data *allocManaged(std::size_t size)
     {
@@ -143,6 +163,15 @@ public:
         return allocManaged<ManagedType>(size, ic);
     }
 
+    template<typename ManagedType>
+    inline typename ManagedType::Data *allocManaged()
+    {
+        auto constexpr size = sizeof(typename ManagedType::Data);
+        Scope scope(engine);
+        Scoped<InternalClass> ic(scope, ManagedType::defaultInternalClass(engine));
+        return allocManaged<ManagedType>(size, ic);
+    }
+
     template <typename ObjectType>
     typename ObjectType::Data *allocateObject(Heap::InternalClass *ic)
     {
@@ -208,7 +237,7 @@ public:
     typename ManagedType::Data *alloc(Args&&... args)
     {
         Scope scope(engine);
-        Scoped<ManagedType> t(scope, allocManaged<ManagedType>(sizeof(typename ManagedType::Data)));
+        Scoped<ManagedType> t(scope, allocManaged<ManagedType>());
         t->d_unchecked()->init(std::forward<Args>(args)...);
         return t->d();
     }
-- 
cgit v1.2.3