Implement CPtr deepcopy and handle CPtr type passing into functions (#1310)

Author: czgdp1807

integration_tests/bindc_03.py

@@ -30,13 +30,27 @@ def f(q_void: CPtr) -> None:
         print(el)
         assert el == i * i + i%2
 
+def h(q_void: CPtr) -> None:
+    i: i32
+    el: i32
+    q: Pointer[i32[:]]
+    c_p_pointer(q_void, q)
+    for i in range(10):
+        # TODO: Use q[i] directly in the assert.
+        el = q[i]
+        print(el)
+        assert el == i * i + i%2
+
 def run():
     a: CPtr
     array_wrapped: ArrayWrapped = ArrayWrapped(a)
+    array_wrapped1: ArrayWrapped
     size: i32
     size = 10
     a = get_array(size)
     array_wrapped.array = a
     f(array_wrapped.array)
+    array_wrapped1 = array_wrapped
+    h(array_wrapped1.array)
 
 run()

src/libasr/codegen/asr_to_llvm.cpp

@@ -5979,22 +5979,26 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
                                 // at the beginning of the function to avoid
                                 // using alloca inside a loop, which would
                                 // run out of stack
-                                llvm::BasicBlock &entry_block = builder->GetInsertBlock()->getParent()->getEntryBlock();
-                                llvm::IRBuilder<> builder0(context);
-                                builder0.SetInsertPoint(&entry_block, entry_block.getFirstInsertionPt());
-                                llvm::AllocaInst *target = builder0.CreateAlloca(
-                                    target_type, nullptr, "call_arg_value");
                                 if( ASR::is_a<ASR::ArrayItem_t>(*x.m_args[i].m_value) ||
                                     ASR::is_a<ASR::StructInstanceMember_t>(*x.m_args[i].m_value) ) {
                                     value = CreateLoad(value);
                                 }
-                                if( ASR::is_a<ASR::Tuple_t>(*arg_type) ||
-                                    ASR::is_a<ASR::List_t>(*arg_type) ) {
-                                    llvm_utils->deepcopy(value, target, arg_type, module.get(), name2memidx);
+                                if( !ASR::is_a<ASR::CPtr_t>(*arg_type) ) {
+                                    llvm::BasicBlock &entry_block = builder->GetInsertBlock()->getParent()->getEntryBlock();
+                                    llvm::IRBuilder<> builder0(context);
+                                    builder0.SetInsertPoint(&entry_block, entry_block.getFirstInsertionPt());
+                                    llvm::AllocaInst *target = builder0.CreateAlloca(
+                                        target_type, nullptr, "call_arg_value");
+                                    if( ASR::is_a<ASR::Tuple_t>(*arg_type) ||
+                                        ASR::is_a<ASR::List_t>(*arg_type) ) {
+                                        llvm_utils->deepcopy(value, target, arg_type, module.get(), name2memidx);
+                                    } else {
+                                        builder->CreateStore(value, target);
+                                    }
+                                    tmp = target;
                                 } else {
-                                    builder->CreateStore(value, target);
+                                    tmp = value;
                                 }
-                                tmp = target;
                             }
                         }
                     }

src/libasr/codegen/llvm_utils.cpp

@@ -313,7 +313,8 @@ namespace LFortran {
                 }
                 break ;
             };
-            case ASR::ttypeType::Character: {
+            case ASR::ttypeType::Character:
+            case ASR::ttypeType::CPtr: {
                 LLVM::CreateStore(*builder, src, dest);
                 break ;
             }