Fix array of object construction, and IO ctors

Author: aaronj0

core/meta/src/TClass.cxx

@@ -5349,6 +5349,7 @@ TClass::ObjectPtr TClass::NewObjectArray(Long_t nElements, ENewType defConstruct
          Error("NewArray", "cannot create object of class %s version %d", GetName(), fClassVersion);
       }
    } else if (HasInterpreterInfo()) {
+      // assert(nElements < 1 && "nelements used in TClass");
       // We have the dictionary but do not have the
       // constructor wrapper, so the dictionary was
       // not generated by rootcint.  Let's try to
@@ -5450,6 +5451,8 @@ TClass::ObjectPtr TClass::NewObjectArray(Long_t nElements, void *arena, ENewType
          Error("NewArray with placement", "cannot create object of class %s version %d at address %p", GetName(), fClassVersion, arena);
       }
    } else if (HasInterpreterInfo()) {
+      // check what nelements is
+      // assert(nElements < 1 && "nelements used in TClass");
       // We have the dictionary but do not have the constructor wrapper,
       // so the dictionary was not generated by rootcint (it was made either
       // by cint or by some external mechanism).  Let's try to create the

core/metacling/src/TClingCallFunc.cxx

@@ -70,6 +70,7 @@ C++ interpreter and the Clang C++ compiler, not CINT.
 #include <map>
 #include <string>
 #include <sstream>
+#include <iostream>
 
 using namespace ROOT;
 using namespace llvm;
@@ -1071,6 +1072,17 @@ tcling_callfunc_ctor_Wrapper_t TClingCallFunc::make_ctor_wrapper(const TClingCla
 {
    // Make a code string that follows this pattern:
    //
+   // This can be a single line if nary and arena are not passed.
+   // TODO : split this into map with 4 wrappers per decl:
+   // *ret = new ClassName;
+   // *ret = new ClassName[nary];
+   // *ret = new (arena) ClassName;
+   // *ret = new (arena) ClassName[nary];
+   // Based on the incoming request
+
+   // Use https://llvm.org/doxygen/classllvm_1_1PointerIntPair.html
+
+
    // void
    // unique_wrapper_ddd(void** ret, void* arena, unsigned long nary)
    // {
@@ -1611,25 +1623,33 @@ void *TClingCallFunc::ExecDefaultConstructor(const TClingClassInfo *info,
       ::Error("TClingCallFunc::ExecDefaultConstructor", "Invalid class info!");
       return nullptr;
    }
-   auto D = info->GetDecl();
-   // bool is_rec = ;
-   if (Cpp::IsClass(D)) {
-      auto FD = Cpp::GetDefaultConstructorConst(D);
-      fJitCall = std::make_unique<Cpp::JitCall>(Cpp::MakeFunctionCallable(FD));
+   // Triage cases when nary is not 0, that is used for construction of multiple objects
+   // use Cpp::Construct 
+
+   if (nary) {
+      // std::cout<<"NARY used: "<<nary<<"\n";
    }
-   else if (Cpp::IsConstructor(D))
-      fJitCall = std::make_unique<Cpp::JitCall>(Cpp::MakeFunctionCallable(D));
 
-   else return nullptr;
+   const clang::Decl* D = info->GetDecl();
+   if (Cpp::IsClass(D))
+      D = (clang::Decl *)Cpp::GetDefaultConstructorConst(D);
+   if (!Cpp::IsConstructor(D))
+      return nullptr;
+
+   Cpp::JitCall JC = Cpp::MakeFunctionCallable(D);
 
-   if(fJitCall->getKind() == Cpp::JitCall::kUnknown) return nullptr;
+   if(JC.getKind() == Cpp::JitCall::kUnknown) return nullptr;
 
+   if(address) {
+      JC.Invoke(&address, {}, (void*)~0, nary);
+      return address;
+   }
+   else {
    // Invoke:
    void *obj = nullptr;
-   fJitCall->Invoke(&obj);
-   // (*wrapper)(&obj, address, nary);
+   JC.Invoke(&obj);
    return obj;
-   
+   }
    // ::Error("TClingCallFunc::ExecDefaultConstructor", "Called with no wrapper, not implemented!");
    // return nullptr;
 }

interpreter/CppInterOp/include/clang/Interpreter/CppInterOp.h

@@ -88,13 +88,17 @@ namespace Cpp {
 
   enum OperatorArity { kUnary = 1, kBinary, kBoth };
 
+  // enum CtorCallType : short 
+  //   { kArena = 0, kArray = 2
+  //   };
+
   /// A class modeling function calls for functions produced by the interpreter
   /// in compiled code. It provides an information if we are calling a standard
   /// function, constructor or destructor.
   class JitCall {
   public:
     friend CPPINTEROP_API JitCall
-    MakeFunctionCallable(TInterp_t I, TCppConstFunction_t func);
+    MakeFunctionCallable(TInterp_t I, TCppConstFunction_t func, bool is_arena, bool is_array);
     enum Kind : char {
       kUnknown = 0,
       kGenericCall,
@@ -111,7 +115,8 @@ namespace Cpp {
     // 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*, int, void**, void*);
+                             // (self,  nargs, args,   result, n_objs)
+    using GenericCall = void (*)(void*, int,   void**, void*,  unsigned long);
     using DestructorCall = void (*)(void*, unsigned long, int);
   private:
     union {
@@ -156,7 +161,7 @@ namespace Cpp {
     // 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 n_objs = 0UL) const {
       // Forward if we intended to call a dtor with only 1 parameter.
       if (m_Kind == kDestructorCall && result && !args.m_Args)
         return InvokeDestructor(result, /*nary=*/0UL, /*withFree=*/true);
@@ -165,7 +170,7 @@ namespace Cpp {
       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, n_objs);
     }
     /// Makes a call to a destructor.
     ///\param[in] object - the pointer of the object whose destructor we call.
@@ -566,10 +571,10 @@ namespace Cpp {
 
   /// Creates a trampoline function by using the interpreter and returns a
   /// uniform interface to call it from compiled code.
-  CPPINTEROP_API JitCall MakeFunctionCallable(TCppConstFunction_t func);
+  CPPINTEROP_API JitCall MakeFunctionCallable(TCppConstFunction_t func, bool is_arena = false, bool is_array = false);
 
   CPPINTEROP_API JitCall MakeFunctionCallable(TInterp_t I,
-                                              TCppConstFunction_t func);
+                                              TCppConstFunction_t func, bool is_arena = false, bool is_array = false);
 
   /// Checks if a function declared is of const type or not.
   CPPINTEROP_API bool IsConstMethod(TCppFunction_t method);
@@ -757,15 +762,15 @@ namespace Cpp {
   CPPINTEROP_API std::vector<long int> GetDimensions(TCppType_t type);
 
   /// Allocates memory for a given class.
-  CPPINTEROP_API TCppObject_t Allocate(TCppScope_t scope);
+  CPPINTEROP_API TCppObject_t Allocate(TCppScope_t scope, int n = 1);
 
   /// 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);
+                                        void* arena = nullptr, unsigned long n_objs = 0UL);
 
   /// Calls the destructor of object of type \c type. When withFree is true it
   /// calls operator delete/free.

interpreter/CppInterOp/lib/Interpreter/CXCppInterOp.cpp

@@ -591,9 +591,10 @@ void clang_deallocate(CXObject address) { ::operator delete(address); }
 
 namespace Cpp {
 void* Construct(compat::Interpreter& interp, TCppScope_t scope,
-                void* arena /*=nullptr*/);
+                void* arena /*=nullptr*/, unsigned long n_objs = 0UL);
 } // namespace Cpp
 
+
 CXObject clang_construct(CXScope scope, void* arena) {
   return Cpp::Construct(*getInterpreter(scope),
                         static_cast<void*>(getDecl(scope)), arena);