Test for tuple return and fixes in CPtrToPointer node in C backend (#1351)

Author: czgdp1807

integration_tests/CMakeLists.txt

@@ -189,6 +189,7 @@ RUN(NAME array_expr_02            LABELS cpython llvm)
 RUN(NAME bindc_01            LABELS cpython llvm c)
 RUN(NAME bindc_02            LABELS cpython llvm c)
 RUN(NAME bindc_04            LABELS llvm c)
+RUN(NAME bindc_07            LABELS llvm c)
 RUN(NAME exit_01             LABELS cpython llvm c)
 RUN(NAME exit_02     FAIL    LABELS cpython llvm c)
 RUN(NAME exit_01b            LABELS cpython llvm c wasm wasm_x86)

integration_tests/bindc_07.py

@@ -0,0 +1,45 @@
+from ltypes import CPtr, i64, sizeof, i32, ccall, c_p_pointer, empty_c_void_p, Pointer, pointer
+from numpy import empty, int64
+
+@ccall
+def _lfortran_malloc(size: i32) -> CPtr:
+    pass
+
+def allocate_memory(size: i32) -> tuple[CPtr, CPtr, CPtr, CPtr]:
+    array1: CPtr = _lfortran_malloc(size * i32(sizeof(i64)))
+    array2: CPtr = _lfortran_malloc(size * i32(sizeof(i64)))
+    array3: CPtr = _lfortran_malloc(size * i32(sizeof(i64)))
+    array4: CPtr = _lfortran_malloc(size * i32(sizeof(i64)))
+    return array1, array2, array3, array4
+
+def sum_arrays(array1: CPtr, array2: CPtr, array3: CPtr, array4: CPtr, size: i32):
+    iarray1: Pointer[i64[size]] = c_p_pointer(array1, i64[size])
+    iarray2: Pointer[i64[size]] = c_p_pointer(array2, i64[size])
+    iarray3: Pointer[i64[size]] = c_p_pointer(array3, i64[size])
+    iarray4: Pointer[i64[size]] = c_p_pointer(array4, i64[size])
+    sum_array_cptr: CPtr = _lfortran_malloc(size * i32(sizeof(i64)))
+    sum_array: Pointer[i64[size]] = c_p_pointer(sum_array_cptr, i64[size])
+    i: i32
+
+    for i in range(size):
+        iarray1[i] = i64(i)
+        iarray2[i] = i64(2 * i)
+        iarray3[i] = i64(3 * i)
+        iarray4[i] = i64(4 * i)
+
+    for i in range(size):
+        sum_array[i] = iarray1[i] + iarray2[i] + iarray3[i] + iarray4[i]
+
+    for i in range(size):
+        print(i, sum_array[i])
+        assert sum_array[i] == i64(10 * i)
+
+def test_tuple_return():
+    a: CPtr = empty_c_void_p()
+    b: CPtr = empty_c_void_p()
+    c: CPtr = empty_c_void_p()
+    d: CPtr = empty_c_void_p()
+    a, b, c, d = allocate_memory(50)
+    sum_arrays(a, b, c, d, 50)
+
+test_tuple_return()

src/libasr/codegen/asr_to_c.cpp

@@ -93,8 +93,9 @@ class ASRToCVisitor : public BaseCCPPVisitor<ASRToCVisitor>
             std::string variable_name = std::string(v_m_name) + "_value";
             sub = format_type_c("", type_name_without_ptr, variable_name, use_ref, dummy) + ";\n";
             sub += indent + format_type_c("", type_name, v_m_name, use_ref, dummy);
-            sub += " = &" + variable_name + ";\n";
+            sub += " = &" + variable_name;
             if( !is_pointer ) {
+                sub += ";\n";
                 if( !is_fixed_size ) {
                     sub += indent + format_type_c("*", type_name_copy, std::string(v_m_name) + "_data",
                                                 use_ref, dummy);
@@ -919,6 +920,36 @@ R"(
         }
     }
 
+    void visit_CPtrToPointer(const ASR::CPtrToPointer_t& x) {
+        visit_expr(*x.m_cptr);
+        std::string source_src = std::move(src);
+        visit_expr(*x.m_ptr);
+        std::string dest_src = std::move(src);
+        src = "";
+        std::string indent(indentation_level*indentation_spaces, ' ');
+        if( ASRUtils::is_array(ASRUtils::expr_type(x.m_ptr)) ) {
+            std::string dim_set_code = "";
+            ASR::dimension_t* m_dims = nullptr;
+            int n_dims = ASRUtils::extract_dimensions_from_ttype(ASRUtils::expr_type(x.m_ptr), m_dims);
+            dim_set_code = indent + dest_src + "->n_dims = " + std::to_string(n_dims) + ";\n";
+            for( int i = 0; i < n_dims; i++ ) {
+                if( m_dims[i].m_start ) {
+                    visit_expr(*m_dims[i].m_start);
+                    dim_set_code += indent + dest_src + "->dims[" + std::to_string(i) + "].lower_bound = " + src + ";\n";
+                }
+                if( m_dims[i].m_length ) {
+                    visit_expr(*m_dims[i].m_length);
+                    dim_set_code += indent + dest_src + "->dims[" + std::to_string(i) + "].length = " + src + ";\n";
+                }
+            }
+            src.clear();
+            src += dim_set_code;
+            dest_src += "->data";
+        }
+        std::string type_src = CUtils::get_c_type_from_ttype_t(ASRUtils::expr_type(x.m_ptr));
+        src += indent + dest_src + " = (" + type_src + ") " + source_src + ";\n";
+    }
+
     void visit_Print(const ASR::Print_t &x) {
         std::string indent(indentation_level*indentation_spaces, ' ');
         std::string out = indent + "printf(\"";

src/libasr/codegen/asr_to_c_cpp.h

@@ -1360,19 +1360,6 @@ R"(#include <stdio.h>
         src = "(" + type_src + ") " + arg_src;
     }
 
-    void visit_CPtrToPointer(const ASR::CPtrToPointer_t& x) {
-        self().visit_expr(*x.m_cptr);
-        std::string source_src = std::move(src);
-        self().visit_expr(*x.m_ptr);
-        std::string dest_src = std::move(src);
-        if( ASRUtils::is_array(ASRUtils::expr_type(x.m_ptr)) ) {
-            dest_src += "->data";
-        }
-        std::string type_src = CUtils::get_c_type_from_ttype_t(ASRUtils::expr_type(x.m_ptr));
-        std::string indent(indentation_level*indentation_spaces, ' ');
-        src = indent + dest_src + " = (" + type_src + ") " + source_src + ";\n";
-    }
-
     void visit_IntegerBinOp(const ASR::IntegerBinOp_t &x) {
         handle_BinOp(x);
     }

tests/reference/c-expr_12-93c7780.json

@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "c-expr_12-93c7780.stdout",
-    "stdout_hash": "1127059fc2c4c1c983f076379c82dc361f4b19498555e14f4442c179",
+    "stdout_hash": "eb08879462b433e55fbbfe330788bea1af316edb842fde0b772f6716",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0

tests/reference/c-expr_12-93c7780.stdout

@@ -70,7 +70,6 @@ void f()
     y->dims[0].length = 2;
     struct i16 yptr1_value;
     struct i16* yptr1 = &yptr1_value;
-;
     g(&yptr1, y);
     check(&yptr1);
 }