Merge pull request #1198 from czgdp1807/sizeof

Adding support for ``sizeof`` in LLVM/C backend

Author: czgdp1807

integration_tests/CMakeLists.txt

@@ -255,6 +255,10 @@ RUN(NAME structs_03          LABELS llvm c)
 RUN(NAME structs_04          LABELS cpython llvm c)
 RUN(NAME structs_05          LABELS llvm c)
 RUN(NAME structs_06          LABELS cpython llvm c)
+RUN(NAME structs_07          LABELS llvm c
+        EXTRAFILES structs_07b.c)
+RUN(NAME sizeof_01          LABELS llvm c
+        EXTRAFILES sizeof_01b.c)
 RUN(NAME enum_01             LABELS cpython llvm c)
 RUN(NAME enum_02             LABELS cpython llvm)
 RUN(NAME enum_03             LABELS cpython llvm c)

integration_tests/sizeof_01.py

@@ -0,0 +1,43 @@
+from ltypes import sizeof, i64, i32, f32, f64, c32, c64, ccall, CPtr
+
+@ccall
+def cmalloc(bytes: i64) -> CPtr:
+    pass
+
+@ccall
+def cfree(x: CPtr) -> bool:
+    pass
+
+@ccall
+def fill_carray(arr: CPtr, size: i32):
+    pass
+
+@ccall
+def sum_carray(arr: CPtr, size: i32) -> i64:
+    pass
+
+def test_sizeof():
+    xi: i32 = 0
+    yi: i64 = 0
+    xf: f32 = 0.0
+    yf: f64 = 0.0
+    xz: c32 = complex(0, 0)
+    yz: c64 = complex(0, 0)
+    assert sizeof(xi) == sizeof(i32)
+    assert sizeof(yi) == sizeof(i64)
+    assert sizeof(xf) == sizeof(f32)
+    assert sizeof(yf) == sizeof(f64)
+    assert sizeof(xz) == sizeof(c32)
+    assert sizeof(yz) == sizeof(c64)
+
+
+def test_c_array():
+    summed_up: i64
+    carray: CPtr = cmalloc(sizeof(i64) * 100)
+    fill_carray(carray, 100)
+    summed_up = sum_carray(carray, 100)
+    print(summed_up)
+    assert summed_up == int(5050)
+
+test_sizeof()
+test_c_array()

integration_tests/sizeof_01b.c

@@ -0,0 +1,27 @@
+#include "sizeof_01b.h"
+#include <stdio.h>
+
+void* cmalloc(int64_t bytes) {
+    return malloc(bytes);
+}
+
+bool cfree(void* x) {
+    free(x);
+    return 1;
+}
+
+void fill_carray(void* arr, int32_t size) {
+    int64_t* arr_int = arr;
+    for( int32_t i = 0; i < size; i++ ) {
+        arr_int[i] = i + 1;
+    }
+}
+
+int64_t sum_carray(void* arr, int32_t size) {
+    int64_t* arr_int = arr;
+    int64_t sum = 0;
+    for( int32_t i = 0; i < size; i++ ) {
+        sum += arr_int[i];
+    }
+    return sum;
+}

integration_tests/sizeof_01b.h

@@ -0,0 +1,8 @@
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+void* cmalloc(int64_t bytes);
+bool cfree(void* x);
+void fill_carray(void* arr, int32_t size);
+int64_t sum_carray(void* arr, int32_t size);

integration_tests/structs_07.py

@@ -0,0 +1,21 @@
+from ltypes import i32, i64, i8, CPtr, sizeof, dataclass, ccall
+
+@dataclass
+class A:
+    x: i32
+    y: i64
+    z: i8
+
+@ccall
+def cmalloc(bytes: i64) -> CPtr:
+    pass
+
+@ccall
+def cfree(x: CPtr) -> i32:
+    pass
+
+def call_malloc():
+   x: CPtr = cmalloc(sizeof(A) * 20)
+   assert cfree(x) == True
+
+call_malloc()

integration_tests/structs_07b.c

@@ -0,0 +1,10 @@
+#include "structs_07b.h"
+
+void* cmalloc(int64_t bytes) {
+    return malloc(bytes);
+}
+
+bool cfree(void* x) {
+    free(x);
+    return 1;
+}

integration_tests/structs_07b.h

@@ -0,0 +1,6 @@
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+void* cmalloc(int64_t bytes);
+bool cfree(void* x);

src/libasr/ASR.asdl

@@ -306,6 +306,8 @@ expr
     | IntegerBitLen(expr a, ttype type, expr? value)
     | Ichar(expr arg, ttype type, expr? value)
 
+    | SizeOfType(ttype arg, ttype type, expr? value)
+
 
 -- `len` in Character:
 -- >=0 ... the length of the string, known at compile time

src/libasr/asr_utils.h

@@ -938,6 +938,27 @@ static inline Vec<char*> get_scope_names(Allocator &al, const SymbolTable *symta
     return scope_names;
 }
 
+static inline ASR::expr_t* get_constant_expression_with_given_type(Allocator& al, ASR::ttype_t* asr_type) {
+    switch (asr_type->type) {
+        case ASR::ttypeType::Integer: {
+            return ASRUtils::EXPR(ASR::make_IntegerConstant_t(al, asr_type->base.loc, -1, asr_type));
+        }
+        case ASR::ttypeType::Real: {
+            return ASRUtils::EXPR(ASR::make_RealConstant_t(al, asr_type->base.loc, 0.0, asr_type));
+        }
+        case ASR::ttypeType::Complex: {
+            return ASRUtils::EXPR(ASR::make_ComplexConstant_t(al, asr_type->base.loc, 0.0, 0.0, asr_type));
+        }
+        case ASR::ttypeType::Logical: {
+            return ASRUtils::EXPR(ASR::make_LogicalConstant_t(al, asr_type->base.loc, false, asr_type));
+        }
+        default: {
+            throw LCompilersException("Not implemented " + std::to_string(asr_type->type));
+        }
+    }
+    return nullptr;
+}
+
 const ASR::intentType intent_local=ASR::intentType::Local; // local variable (not a dummy argument)
 const ASR::intentType intent_in   =ASR::intentType::In; // dummy argument, intent(in)
 const ASR::intentType intent_out  =ASR::intentType::Out; // dummy argument, intent(out)

src/libasr/codegen/asr_to_c_cpp.h

@@ -924,6 +924,11 @@ R"(#include <stdio.h>
         }
     }
 
+    void visit_SizeOfType(const ASR::SizeOfType_t& x) {
+        std::string c_type = get_c_type_from_ttype_t(x.m_arg);
+        src = "sizeof(" + c_type + ")";
+    }
+
     void visit_StringSection(const ASR::StringSection_t& x) {
         self().visit_expr(*x.m_arg);
         std::string arg, left, right, step, left_present, rig_present;
@@ -1571,6 +1576,26 @@ R"(#include <stdio.h>
                 type_src = list_type_c;
                 break;
             }
+            case ASR::ttypeType::Complex: {
+                if( kind == 4 ) {
+                    if( is_c ) {
+                        headers.insert("complex");
+                        type_src = "float complex";
+                    } else {
+                        type_src = "std::complex<float>";
+                    }
+                } else if( kind == 8 ) {
+                    if( is_c ) {
+                        headers.insert("complex");
+                        type_src = "double complex";
+                    } else {
+                        type_src = "std::complex<double>";
+                    }
+                } else {
+                    throw CodeGenError(std::to_string(kind * 8) + "-bit floating points not yet supported.");
+                }
+                break;
+            }
             default: {
                 throw CodeGenError("Type " + ASRUtils::type_to_str_python(t) + " not supported yet.");
             }