Array of objects in Construct/Destruct/Allocate/Deallocate

Author: aaronj0

include/CppInterOp/CppInterOp.h

@@ -115,8 +115,10 @@ class JitCall {
   // FIXME: Figure out how to unify the wrapper signatures.
   // FIXME: Hide these implementation details by moving wrapper generation in
   // this class.
-  using GenericCall = void (*)(void*, size_t, void**, void*);
-  using DestructorCall = void (*)(void*, unsigned long, int);
+  // (self, nargs, args, result, nary)
+  using GenericCall = void (*)(void*, size_t, void**, void*, size_t);
+  // (self, nary, withFree)
+  using DestructorCall = void (*)(void*, size_t, int);
 
 private:
   union {
@@ -162,19 +164,20 @@ class JitCall {
   // self can go in the end and be nullptr by default; result can be a nullptr
   // by default. These changes should be synchronized with the wrapper if we
   // decide to directly.
-  void Invoke(void* result, ArgList args = {}, void* self = nullptr) const {
+  void Invoke(void* result, ArgList args = {}, void* self = nullptr,
+              size_t nary = 0UL) const {
     // NOLINTBEGIN(*-type-union-access)
     // Forward if we intended to call a dtor with only 1 parameter.
     if (m_Kind == kDestructorCall && result && !args.m_Args) {
-      InvokeDestructor(result, /*nary=*/0UL, /*withFree=*/true);
+      InvokeDestructor(result, nary, /*withFree=*/true);
       return;
     }
 
 #ifndef NDEBUG
     assert(AreArgumentsValid(result, args, self) && "Invalid args!");
     ReportInvokeStart(result, args, self);
 #endif // NDEBUG
-    m_GenericCall(self, args.m_ArgSize, args.m_Args, result);
+    m_GenericCall(self, args.m_ArgSize, args.m_Args, result, nary);
     // NOLINTEND(*-type-union-access)
   }
   /// Makes a call to a destructor.
@@ -791,20 +794,33 @@ enum : long int {
 /// Gets the size/dimensions of a multi-dimension array.
 CPPINTEROP_API std::vector<long int> GetDimensions(TCppType_t type);
 
-/// Allocates memory for a given class.
-CPPINTEROP_API TCppObject_t Allocate(TCppScope_t scope);
+/// Allocates memory required by an object of a given class
+/// \c scope Given class for which to allocate memory for
+/// \c count is used to indicate the number of objects to allocate for.
+CPPINTEROP_API TCppObject_t Allocate(TCppScope_t scope,
+                                     TCppIndex_t count = 1UL);
 
 /// Deallocates memory for a given class.
-CPPINTEROP_API void Deallocate(TCppScope_t scope, TCppObject_t address);
-
-/// Creates an object of class \c scope and calls its default constructor. If
-/// \c arena is set it uses placement new.
-CPPINTEROP_API TCppObject_t Construct(TCppScope_t scope, void* arena = nullptr);
-
-/// Calls the destructor of object of type \c type. When withFree is true it
-/// calls operator delete/free.
+/// \c scope Class to indicate size of memory to deallocate
+/// \c count is used to indicate the number of objects to dallocate for
+CPPINTEROP_API void Deallocate(TCppScope_t scope, TCppObject_t address,
+                               TCppIndex_t count = 1UL);
+
+/// Creates one or more objects of class \c scope by calling its default
+/// constructor.
+/// \c arena If set, this API uses placement new to construct at this address.
+/// \c count is used to indicate the number of objects to construct.
+CPPINTEROP_API TCppObject_t Construct(TCppScope_t scope, void* arena = nullptr,
+                                      TCppIndex_t count = 1UL);
+
+/// Destroys one or more objects of a class
+/// \c This this pointer of the object to destruct. Can also be the starting
+/// address of an array of objects
+/// \c withFree if true, we call operator delete/free, else just the destructor
+/// \c count indicate the number of objects to destruct, if \c This points to
+/// an array of objects
 CPPINTEROP_API void Destruct(TCppObject_t This, TCppScope_t type,
-                             bool withFree = true);
+                             bool withFree = true, TCppIndex_t count = 0UL);
 
 /// @name Stream Redirection
 ///

include/clang-c/CXCppInterOp.h

@@ -332,7 +332,8 @@ CINDEX_LINKAGE void clang_deallocate(CXObject address);
  * Creates an object of class \c scope and calls its default constructor. If \c
  * arena is set it uses placement new.
  */
-CINDEX_LINKAGE CXObject clang_construct(CXScope scope, void* arena);
+CINDEX_LINKAGE CXObject clang_construct(CXScope scope, void* arena,
+                                        size_t count);
 
 /**
  * Creates a trampoline function and makes a call to a generic function or
@@ -349,7 +350,7 @@ CINDEX_LINKAGE CXObject clang_construct(CXScope scope, void* arena);
  * \param self The 'this pointer' of the object.
  */
 CINDEX_LINKAGE void clang_invoke(CXScope func, void* result, void** args,
-                                 size_t n, void* self);
+                                 size_t n, size_t nary, void* self);
 
 /**
  * Calls the destructor of object of type \c type. When withFree is true it
@@ -361,7 +362,8 @@ CINDEX_LINKAGE void clang_invoke(CXScope func, void* result, void** args,
  *
  * \param withFree Whether to call operator delete/free or not.
  */
-CINDEX_LINKAGE void clang_destruct(CXObject This, CXScope S, bool withFree);
+CINDEX_LINKAGE void clang_destruct(CXObject This, CXScope S,
+                                   bool withFree = true, size_t nary = 0UL);
 
 /**
  * @}

lib/CppInterOp/CXCppInterOp.cpp

@@ -597,25 +597,25 @@ void clang_deallocate(CXObject address) { ::operator delete(address); }
 
 namespace Cpp {
 void* Construct(compat::Interpreter& interp, TCppScope_t scope,
-                void* arena /*=nullptr*/);
+                void* arena /*=nullptr*/, TCppIndex_t count);
 } // namespace Cpp
 
-CXObject clang_construct(CXScope scope, void* arena) {
+CXObject clang_construct(CXScope scope, void* arena, size_t count) {
   return Cpp::Construct(*getInterpreter(scope),
-                        static_cast<void*>(getDecl(scope)), arena);
+                        static_cast<void*>(getDecl(scope)), arena, count);
 }
 
 void clang_invoke(CXScope func, void* result, void** args, size_t n,
-                  void* self) {
+                  size_t nary, void* self) {
   Cpp::MakeFunctionCallable(getInterpreter(func), getDecl(func))
-      .Invoke(result, {args, n}, self);
+      .Invoke(result, {args, n}, self, nary);
 }
 
 namespace Cpp {
 void Destruct(compat::Interpreter& interp, TCppObject_t This,
-              clang::Decl* Class, bool withFree);
+              clang::Decl* Class, bool withFree, size_t nary);
 } // namespace Cpp
 
-void clang_destruct(CXObject This, CXScope S, bool withFree) {
-  Cpp::Destruct(*getInterpreter(S), This, getDecl(S), withFree);
+void clang_destruct(CXObject This, CXScope S, bool withFree, size_t nary) {
+  Cpp::Destruct(*getInterpreter(S), This, getDecl(S), withFree, nary);
 }

lib/CppInterOp/CppInterOp.cpp

@@ -3646,17 +3646,18 @@ void GetOperator(TCppScope_t scope, Operator op,
   }
 }
 
-TCppObject_t Allocate(TCppScope_t scope) {
-  return (TCppObject_t)::operator new(Cpp::SizeOf(scope));
+TCppObject_t Allocate(TCppScope_t scope, TCppIndex_t count) {
+  return (TCppObject_t)::operator new(Cpp::SizeOf(scope) * count);
 }
 
-void Deallocate(TCppScope_t scope, TCppObject_t address) {
-  ::operator delete(address);
+void Deallocate(TCppScope_t scope, TCppObject_t address, TCppIndex_t count) {
+  size_t bytes = Cpp::SizeOf(scope) * count;
+  ::operator delete(address, bytes);
 }
 
 // FIXME: Add optional arguments to the operator new.
 TCppObject_t Construct(compat::Interpreter& interp, TCppScope_t scope,
-                       void* arena /*=nullptr*/) {
+                       void* arena /*=nullptr*/, TCppIndex_t count /*=1UL*/) {
   auto* Class = (Decl*)scope;
   // FIXME: Diagnose.
   if (!HasDefaultConstructor(Class))
@@ -3665,7 +3666,8 @@ TCppObject_t Construct(compat::Interpreter& interp, TCppScope_t scope,
   auto* const Ctor = GetDefaultConstructor(interp, Class);
   if (JitCall JC = MakeFunctionCallable(&interp, Ctor)) {
     if (arena) {
-      JC.Invoke(&arena, {}, (void*)~0); // Tell Invoke to use placement new.
+      JC.Invoke(&arena, {}, (void*)~0,
+                count); // Tell Invoke to use placement new.
       return arena;
     }
 
@@ -3676,22 +3678,24 @@ TCppObject_t Construct(compat::Interpreter& interp, TCppScope_t scope,
   return nullptr;
 }
 
-TCppObject_t Construct(TCppScope_t scope, void* arena /*=nullptr*/) {
-  return Construct(getInterp(), scope, arena);
+TCppObject_t Construct(TCppScope_t scope, void* arena /*=nullptr*/,
+                       TCppIndex_t count /*=1UL*/) {
+  return Construct(getInterp(), scope, arena, count);
 }
 
 void Destruct(compat::Interpreter& interp, TCppObject_t This, Decl* Class,
-              bool withFree) {
+              bool withFree, TCppIndex_t nary) {
   if (auto wrapper = make_dtor_wrapper(interp, Class)) {
-    (*wrapper)(This, /*nary=*/0, withFree);
+    (*wrapper)(This, nary, withFree);
     return;
   }
   // FIXME: Diagnose.
 }
 
-void Destruct(TCppObject_t This, TCppScope_t scope, bool withFree /*=true*/) {
+void Destruct(TCppObject_t This, TCppScope_t scope, bool withFree /*=true*/,
+              TCppIndex_t count /*=0UL*/) {
   auto* Class = static_cast<Decl*>(scope);
-  Destruct(getInterp(), This, Class, withFree);
+  Destruct(getInterp(), This, Class, withFree, count);
 }
 
 class StreamCaptureInfo {

unittests/CppInterOp/FunctionReflectionTest.cpp

@@ -1483,7 +1483,7 @@ TEST(FunctionReflectionTest, JitCallAdvanced) {
   auto* I = clang_createInterpreterFromRawPtr(Cpp::GetInterpreter());
   auto S = clang_getDefaultConstructor(make_scope(Decls[0], I));
   void* object_c = nullptr;
-  clang_invoke(S, &object_c, nullptr, 0, nullptr);
+  clang_invoke(S, &object_c, nullptr, 0, 0UL, nullptr);
   EXPECT_TRUE(object_c) << "Failed to call the ctor.";
   clang_destruct(object_c, make_scope(Decls[1], I), true);
   // Clean up resources
@@ -2014,7 +2014,7 @@ TEST(FunctionReflectionTest, Construct) {
   testing::internal::CaptureStdout();
   auto* I = clang_createInterpreterFromRawPtr(Cpp::GetInterpreter());
   auto scope_c = make_scope(static_cast<clang::Decl*>(scope), I);
-  auto object_c = clang_construct(scope_c, nullptr);
+  auto object_c = clang_construct(scope_c, nullptr, 0UL);
   EXPECT_TRUE(object_c != nullptr);
   output = testing::internal::GetCapturedStdout();
   EXPECT_EQ(output, "Constructor Executed");
@@ -2137,7 +2137,7 @@ TEST(FunctionReflectionTest, Destruct) {
   testing::internal::CaptureStdout();
   auto* I = clang_createInterpreterFromRawPtr(Cpp::GetInterpreter());
   auto scope_c = make_scope(static_cast<clang::Decl*>(scope), I);
-  auto object_c = clang_construct(scope_c, nullptr);
+  auto object_c = clang_construct(scope_c, nullptr, 0UL);
   clang_destruct(object_c, scope_c, true);
   output = testing::internal::GetCapturedStdout();
   EXPECT_EQ(output, "Destructor Executed");