Create temporary variable for storing structs returned by value

Author: czgdp1807

integration_tests/test_list_01.py

@@ -1,12 +1,21 @@
 from ltypes import f64, i32
 
+def fill_list_i32(size: i32) -> list[i32]:
+    aarg: list[i32] = [0, 1, 2, 3, 4]
+    i: i32
+    for i in range(10):
+        aarg.append(i + 5)
+    return aarg
+
+
 def test_list_01():
-    a: list[i32] = [0, 1, 2, 3, 4]
+    a: list[i32] = []
     f: list[f64] = [1.0, 2.0, 3.0, 4.0, 5.0]
     i: i32
 
+    a = fill_list_i32(10)
+
     for i in range(10):
-        a.append(i + 5)
         f.append(float(i + 6))
 
     for i in range(15):

src/libasr/codegen/asr_to_llvm.cpp

@@ -2983,15 +2983,11 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
             this->visit_expr(*x.m_value);
             llvm::Value* value_list = tmp;
             ptr_loads = ptr_loads_copy;
-            if (ASR::is_a<ASR::FunctionCall_t>(*x.m_value)) {
-                builder->CreateStore(value_list, target_list);
-            } else {
-                ASR::List_t* value_asr_list = ASR::down_cast<ASR::List_t>(
-                                                ASRUtils::expr_type(x.m_value));
-                std::string value_type_code = ASRUtils::get_type_code(value_asr_list->m_type);
-                list_api->list_deepcopy(value_list, target_list,
-                                        value_asr_list, *module);
-            }
+            ASR::List_t* value_asr_list = ASR::down_cast<ASR::List_t>(
+                                            ASRUtils::expr_type(x.m_value));
+            std::string value_type_code = ASRUtils::get_type_code(value_asr_list->m_type);
+            list_api->list_deepcopy(value_list, target_list,
+                                    value_asr_list, *module);
             return ;
         } else if( is_target_tuple && is_value_tuple ) {
             uint64_t ptr_loads_copy = ptr_loads;
@@ -3023,15 +3019,11 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
                 this->visit_expr(*x.m_target);
                 llvm::Value* target_tuple = tmp;
                 ptr_loads = ptr_loads_copy;
-                if( ASR::is_a<ASR::FunctionCall_t>(*x.m_value) ) {
-                    builder->CreateStore(value_tuple, target_tuple);
-                } else {
-                    ASR::Tuple_t* value_tuple_type = ASR::down_cast<ASR::Tuple_t>(asr_value_type);
-                    std::string type_code = ASRUtils::get_type_code(value_tuple_type->m_type,
-                                                                    value_tuple_type->n_type);
-                    tuple_api->tuple_deepcopy(value_tuple, target_tuple,
-                                              value_tuple_type, *module);
-                }
+                ASR::Tuple_t* value_tuple_type = ASR::down_cast<ASR::Tuple_t>(asr_value_type);
+                std::string type_code = ASRUtils::get_type_code(value_tuple_type->m_type,
+                                                                value_tuple_type->n_type);
+                tuple_api->tuple_deepcopy(value_tuple, target_tuple,
+                                          value_tuple_type, *module);
             }
             return ;
         }
@@ -5222,6 +5214,41 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
         tmp = builder->CreateOr(arg1, arg2);
     }
 
+    llvm::Value* CreatePointerToStructReturnValue(llvm::FunctionType* fnty,
+                                                  llvm::Value* return_value,
+                                                  ASR::ttype_t* asr_return_type) {
+        if( !LLVM::is_llvm_struct(asr_return_type) ) {
+            return return_value;
+        }
+
+        // Call to LLVM APIs not needed to fetch the return type of the function.
+        // We can use asr_return_type as well but anyways for compactness I did it here.
+        llvm::Value* pointer_to_struct = builder->CreateAlloca(fnty->getReturnType(), nullptr);
+        LLVM::CreateStore(*builder, return_value, pointer_to_struct);
+        return pointer_to_struct;
+    }
+
+    llvm::Value* CreateCallUtil(llvm::FunctionType* fnty, llvm::Value* fn,
+                                std::vector<llvm::Value*>& args,
+                                ASR::ttype_t* asr_return_type) {
+        llvm::Value* return_value = builder->CreateCall(fnty, fn, args);
+        return CreatePointerToStructReturnValue(fnty, return_value,
+                                                asr_return_type);
+    }
+
+    llvm::Value* CreateCallUtil(llvm::FunctionType* fnty, llvm::Function* fn,
+                                std::vector<llvm::Value*>& args,
+                                ASR::ttype_t* asr_return_type) {
+        llvm::Value* return_value = builder->CreateCall(fn, args);
+        return CreatePointerToStructReturnValue(fnty, return_value,
+                                                asr_return_type);
+    }
+
+    llvm::Value* CreateCallUtil(llvm::Function* fn, std::vector<llvm::Value*>& args,
+                                ASR::ttype_t* asr_return_type) {
+        return CreateCallUtil(fn->getFunctionType(), fn, args, asr_return_type);
+    }
+
     void visit_FunctionCall(const ASR::FunctionCall_t &x) {
         if( ASRUtils::is_intrinsic_optimization(x.m_name) ) {
             ASR::Function_t* routine = ASR::down_cast<ASR::Function_t>(
@@ -5306,7 +5333,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
             llvm::FunctionType* fntype = llvm_symtab_fn[h]->getFunctionType();
             std::string m_name = std::string(((ASR::Function_t*)(&(x.m_name->base)))->m_name);
             args = convert_call_args(x, m_name);
-            tmp = builder->CreateCall(fntype, fn, args);
+            tmp = CreateCallUtil(fntype, fn, args, x.m_type);
         } else if (llvm_symtab_fn.find(h) == llvm_symtab_fn.end()) {
             throw CodeGenError("Function code not generated for '"
                 + std::string(s->m_name) + "'");
@@ -5315,8 +5342,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
             std::string m_name = std::string(((ASR::Function_t*)(&(x.m_name->base)))->m_name);
             std::vector<llvm::Value *> args2 = convert_call_args(x, m_name);
             args.insert(args.end(), args2.begin(), args2.end());
+            ASR::ttype_t *return_var_type0 = EXPR2VAR(s->m_return_var)->m_type;
             if (s->m_abi == ASR::abiType::BindC) {
-                ASR::ttype_t *return_var_type0 = EXPR2VAR(s->m_return_var)->m_type;
                 if (is_a<ASR::Complex_t>(*return_var_type0)) {
                     int a_kind = down_cast<ASR::Complex_t>(return_var_type0)->m_kind;
                     if (a_kind == 8) {
@@ -5337,6 +5364,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
                 }
             } else {
                 tmp = builder->CreateCall(fn, args);
+                tmp = CreateCallUtil(fn, args, return_var_type0);
             }
         }
         if (s->m_abi == ASR::abiType::BindC) {