Some changes

Author: czgdp1807

src/libasr/asr_utils.cpp

@@ -1570,7 +1570,7 @@ ASR::asr_t* make_Cmpop_util(Allocator &al, const Location& loc, ASR::cmpopType c
 
 void make_ArrayBroadcast_t_util(Allocator& al, const Location& loc,
     ASR::expr_t*& expr1, ASR::expr_t*& expr2, ASR::dimension_t* expr1_mdims,
-    size_t expr1_ndims) {
+    size_t expr1_ndims, bool is_simd_array=false) {
     ASR::ttype_t* expr1_type = ASRUtils::expr_type(expr1);
     Vec<ASR::expr_t*> shape_args;
     shape_args.reserve(al, 1);
@@ -1612,7 +1612,8 @@ void make_ArrayBroadcast_t_util(Allocator& al, const Location& loc,
         dims.push_back(al, dim);
 
         if( ASRUtils::is_value_constant(expr2) &&
-            ASRUtils::get_fixed_size_of_array(expr1_mdims, expr1_ndims) <= 256 ) {
+            ASRUtils::get_fixed_size_of_array(expr1_mdims, expr1_ndims) <= 256 &&
+            is_simd_array ) {
             ASR::ttype_t* value_type = ASRUtils::TYPE(ASR::make_Array_t(al, loc,
                 ASRUtils::type_get_past_array(ASRUtils::expr_type(expr2)), dims.p, dims.size(),
                 is_value_character_array && !ASRUtils::is_value_constant(expr2) ? ASR::array_physical_typeType::StringArraySinglePointer: ASR::array_physical_typeType::FixedSizeArray));
@@ -1654,7 +1655,7 @@ void make_ArrayBroadcast_t_util(Allocator& al, const Location& loc,
 }
 
 void make_ArrayBroadcast_t_util(Allocator& al, const Location& loc,
-    ASR::expr_t*& expr1, ASR::expr_t*& expr2) {
+    ASR::expr_t*& expr1, ASR::expr_t*& expr2, bool is_simd_array) {
     ASR::ttype_t* expr1_type = ASRUtils::expr_type(expr1);
     ASR::ttype_t* expr2_type = ASRUtils::expr_type(expr2);
     ASR::dimension_t *expr1_mdims = nullptr, *expr2_mdims = nullptr;
@@ -1669,12 +1670,12 @@ void make_ArrayBroadcast_t_util(Allocator& al, const Location& loc,
         if( ASR::is_a<ASR::ArrayReshape_t>(*expr2) ) {
             return ;
         }
-        make_ArrayBroadcast_t_util(al, loc, expr1, expr2, expr1_mdims, expr1_ndims);
+        make_ArrayBroadcast_t_util(al, loc, expr1, expr2, expr1_mdims, expr1_ndims, is_simd_array);
     } else {
         if( ASR::is_a<ASR::ArrayReshape_t>(*expr1) ) {
             return ;
         }
-        make_ArrayBroadcast_t_util(al, loc, expr2, expr1, expr2_mdims, expr2_ndims);
+        make_ArrayBroadcast_t_util(al, loc, expr2, expr1, expr2_mdims, expr2_ndims, is_simd_array);
     }
 }
 

src/libasr/asr_utils.h

@@ -5799,7 +5799,7 @@ inline ASR::asr_t* make_ArrayConstructor_t_util(Allocator &al, const Location &a
 }
 
 void make_ArrayBroadcast_t_util(Allocator& al, const Location& loc,
-    ASR::expr_t*& expr1, ASR::expr_t*& expr2);
+    ASR::expr_t*& expr1, ASR::expr_t*& expr2, bool is_simd_array=false);
 
 // Wraps argument in stringformat if it's not a single argument of type Character.
 static inline ASR::asr_t* make_print_t_util(Allocator& al, const Location& loc,

src/libasr/pass/intrinsic_functions.h

@@ -3351,7 +3351,7 @@ namespace FloorDiv {
             CastingUtil::perform_casting(args[1], real64, al, loc))));
         body.push_back(al, b.Assignment(tmp, b.r2i_t(r, int64)));
         body.push_back(al, b.If(b.And(b.Lt(r, b.f_t(0.0, real64)), b.NotEq(b.i2r_t(tmp, real64), r)), {
-                b.Assignment(tmp, b.Sub(tmp, b.i32(1)))
+                b.Assignment(tmp, b.Sub(tmp, b.i64(1)))
             }, {}));
         body.push_back(al, b.Assignment(result, CastingUtil::perform_casting(tmp, return_type, al, loc)));
         ASR::symbol_t *f_sym = make_ASR_Function_t(fn_name, fn_symtab, dep, args,

src/lpython/semantics/python_ast_to_asr.cpp

@@ -8464,8 +8464,10 @@ we will have to use something else.
                     throw SemanticError("Function '" + call_name + "' does not accept vector values",
                         x.base.base.loc);
                 }
-                args_.push_back(al,
-                    make_ConstantWithKind(make_IntegerConstant_t, make_Integer_t, 8, 4, x.base.base.loc));
+                if( intrinsic_name == "int" ) {
+                    args_.push_back(al,
+                        make_ConstantWithKind(make_IntegerConstant_t, make_Integer_t, 8, 4, x.base.base.loc));
+                }
                 tmp = create_func(al, x.base.base.loc, args_, diag);
                 if( tmp == nullptr ) {
                     throw SemanticAbort();
@@ -8630,10 +8632,33 @@ we will have to use something else.
                                 alloc_args_vec.p, alloc_args_vec.size(),
                                 nullptr, nullptr, nullptr);
                 } else {
-                    Vec<ASR::expr_t*> arr_args;
-                    arr_args.reserve(al, 0);
-                    tmp = ASRUtils::make_ArrayConstructor_t_util(al, x.base.base.loc,
-                        arr_args.p, arr_args.size(), type, ASR::arraystorageType::RowMajor);
+                    const Location& loc = x.base.base.loc;
+                    ASR::ttype_t* el_type = ASRUtils::type_get_past_array(
+                        ASRUtils::type_get_past_allocatable_pointer(type));
+                    if( !ASRUtils::is_struct(*el_type) ) {
+                        ASR::expr_t* zero = ASRUtils::get_constant_zero_with_given_type(al, el_type);
+                        LCOMPILERS_ASSERT(assign_asr_target)
+                        ASRUtils::make_ArrayBroadcast_t_util(al, x.base.base.loc, assign_asr_target, zero, false);
+                        tmp = &(zero->base);
+                    } else {
+                        ASR::expr_t* zero = ASRUtils::get_constant_zero_with_given_type(al, int32);
+                        LCOMPILERS_ASSERT(assign_asr_target)
+                        size_t rank = ASRUtils::extract_n_dims_from_ttype(type);
+                        Vec<ASR::array_index_t> array_index; array_index.reserve(al, rank);
+                        for( size_t i = 0; i < rank; i++ ) {
+                            ASR::array_index_t idx;
+                            idx.loc = loc;
+                            idx.m_left = nullptr;
+                            idx.m_right = zero;
+                            idx.m_step = nullptr;
+                            array_index.push_back(al, idx);
+                        }
+                        ASR::expr_t* arrayitem = ASRUtils::EXPR(ASR::make_ArrayItem_t(
+                            al, loc, assign_asr_target, array_index.p, array_index.size(),
+                            el_type, ASR::arraystorageType::RowMajor, nullptr));
+                        ASRUtils::make_ArrayBroadcast_t_util(al, x.base.base.loc, assign_asr_target, arrayitem, false);
+                        tmp = &(arrayitem->base);
+                    }
                 }
                 return;
             } else if (call_name == "c_p_pointer") {