#include <libasr/assert.h>

#include <libasr/codegen/llvm_utils.h>

#include <libasr/codegen/llvm_array_utils.h>

#include <libasr/asr_utils.h>

namespace LCompilers {

namespace LLVM {

llvm::Value* CreateLoad(llvm::IRBuilder<> &builder, llvm::Value *x) {

llvm::Type *t = x->getType();

LCOMPILERS_ASSERT(t->isPointerTy());

llvm::Type *t2 = t->getContainedType(0);

return builder.CreateLoad(t2, x);

}

llvm::Value* CreateStore(llvm::IRBuilder<> &builder, llvm::Value *x, llvm::Value *y) {

LCOMPILERS_ASSERT(y->getType()->isPointerTy());

return builder.CreateStore(x, y);

}

llvm::Value* CreateGEP(llvm::IRBuilder<> &builder, llvm::Value *x, std::vector<llvm::Value *> &idx) {

llvm::Type *t = x->getType();

LCOMPILERS_ASSERT(t->isPointerTy());

llvm::Type *t2 = t->getContainedType(0);

return builder.CreateGEP(t2, x, idx);

}

llvm::Value* CreateInBoundsGEP(llvm::IRBuilder<> &builder, llvm::Value *x, std::vector<llvm::Value *> &idx) {

llvm::Type *t = x->getType();

LCOMPILERS_ASSERT(t->isPointerTy());

llvm::Type *t2 = t->getContainedType(0);

return builder.CreateInBoundsGEP(t2, x, idx);

}

llvm::Value* lfortran_malloc(llvm::LLVMContext &context, llvm::Module &module,

llvm::IRBuilder<> &builder, llvm::Value* arg_size) {

std::string func_name = "_lfortran_malloc";

llvm::Function *fn = module.getFunction(func_name);

if (!fn) {

llvm::FunctionType *function_type = llvm::FunctionType::get(

llvm::Type::getInt8PtrTy(context), {

llvm::Type::getInt32Ty(context)

}, true);

fn = llvm::Function::Create(function_type,

llvm::Function::ExternalLinkage, func_name, module);

}

std::vector<llvm::Value*> args = {arg_size};

return builder.CreateCall(fn, args);

}

llvm::Value* lfortran_calloc(llvm::LLVMContext &context, llvm::Module &module,

llvm::IRBuilder<> &builder, llvm::Value* count, llvm::Value* type_size) {

std::string func_name = "_lfortran_calloc";

llvm::Function *fn = module.getFunction(func_name);

if (!fn) {

llvm::FunctionType *function_type = llvm::FunctionType::get(

llvm::Type::getInt8PtrTy(context), {

llvm::Type::getInt32Ty(context),

llvm::Type::getInt32Ty(context)

}, true);

fn = llvm::Function::Create(function_type,

llvm::Function::ExternalLinkage, func_name, module);

}

std::vector<llvm::Value*> args = {count, type_size};

return builder.CreateCall(fn, args);

}

llvm::Value* lfortran_realloc(llvm::LLVMContext &context, llvm::Module &module,

llvm::IRBuilder<> &builder, llvm::Value* ptr, llvm::Value* arg_size) {

std::string func_name = "_lfortran_realloc";

llvm::Function *fn = module.getFunction(func_name);

if (!fn) {

llvm::FunctionType *function_type = llvm::FunctionType::get(

llvm::Type::getInt8PtrTy(context), {

llvm::Type::getInt8PtrTy(context),

llvm::Type::getInt32Ty(context)

}, true);

fn = llvm::Function::Create(function_type,

llvm::Function::ExternalLinkage, func_name, module);

}

std::vector<llvm::Value*> args = {

builder.CreateBitCast(ptr, llvm::Type::getInt8PtrTy(context)),

arg_size

};

return builder.CreateCall(fn, args);

}

llvm::Value* lfortran_free(llvm::LLVMContext &context, llvm::Module &module,

llvm::IRBuilder<> &builder, llvm::Value* ptr) {

std::string func_name = "_lfortran_free";

llvm::Function *fn = module.getFunction(func_name);

if (!fn) {

llvm::FunctionType *function_type = llvm::FunctionType::get(

llvm::Type::getVoidTy(context), {

llvm::Type::getInt8PtrTy(context)

}, true);

fn = llvm::Function::Create(function_type,

llvm::Function::ExternalLinkage, func_name, module);

}

std::vector<llvm::Value*> args = {

builder.CreateBitCast(ptr, llvm::Type::getInt8PtrTy(context)),

};

return builder.CreateCall(fn, args);

}

} // namespace LLVM

LLVMUtils::LLVMUtils(llvm::LLVMContext& context,

llvm::IRBuilder<>* _builder, std::string& der_type_name_,

std::map<std::string, llvm::StructType*>& name2dertype_,

std::map<std::string, llvm::StructType*>& name2dercontext_,

std::vector<std::string>& struct_type_stack_,

std::map<std::string, std::string>& dertype2parent_,

std::map<std::string, std::map<std::string, int>>& name2memidx_,

CompilerOptions &compiler_options_,

std::unordered_map<std::uint32_t, std::unordered_map<std::string, llvm::Type*>>& arr_arg_type_cache_,

std::map<std::string, std::pair<llvm::Type*, llvm::Type*>>& fname2arg_type_):

context(context), builder(std::move(_builder)), str_cmp_itr(nullptr), der_type_name(der_type_name_),

name2dertype(name2dertype_), name2dercontext(name2dercontext_),

struct_type_stack(struct_type_stack_), dertype2parent(dertype2parent_),

name2memidx(name2memidx_), arr_arg_type_cache(arr_arg_type_cache_), fname2arg_type(fname2arg_type_),

dict_api_lp(nullptr), dict_api_sc(nullptr),

set_api_lp(nullptr), set_api_sc(nullptr), compiler_options(compiler_options_) {

std::vector<llvm::Type*> els_4 = {

llvm::Type::getFloatTy(context),

llvm::Type::getFloatTy(context)};

std::vector<llvm::Type*> els_8 = {

llvm::Type::getDoubleTy(context),

llvm::Type::getDoubleTy(context)};

std::vector<llvm::Type*> els_4_ptr = {

llvm::Type::getFloatPtrTy(context),

llvm::Type::getFloatPtrTy(context)};

std::vector<llvm::Type*> els_8_ptr = {

llvm::Type::getDoublePtrTy(context),

llvm::Type::getDoublePtrTy(context)};

complex_type_4 = llvm::StructType::create(context, els_4, "complex_4");

complex_type_8 = llvm::StructType::create(context, els_8, "complex_8");

complex_type_4_ptr = llvm::StructType::create(context, els_4_ptr, "complex_4_ptr");

complex_type_8_ptr = llvm::StructType::create(context, els_8_ptr, "complex_8_ptr");

character_type = llvm::Type::getInt8PtrTy(context);

}

void LLVMUtils::set_module(llvm::Module* module_) {

module = module_;

}

llvm::Type* LLVMUtils::getMemberType(ASR::ttype_t* mem_type, ASR::Variable_t* member,

llvm::Module* module) {

llvm::Type* llvm_mem_type = nullptr;

switch( mem_type->type ) {

case ASR::ttypeType::Integer: {

int a_kind = ASR::down_cast<ASR::Integer_t>(mem_type)->m_kind;

llvm_mem_type = getIntType(a_kind);

break;

}

case ASR::ttypeType::Real: {

int a_kind = ASR::down_cast<ASR::Real_t>(mem_type)->m_kind;

llvm_mem_type = getFPType(a_kind);

break;

}

case ASR::ttypeType::Struct: {

llvm_mem_type = getStructType(mem_type, module);

break;

}

case ASR::ttypeType::Enum: {

llvm_mem_type = llvm::Type::getInt32Ty(context);

break ;

}

case ASR::ttypeType::Union: {

llvm_mem_type = getUnionType(mem_type, module);

break;

}

case ASR::ttypeType::Allocatable: {

ASR::Allocatable_t* ptr_type = ASR::down_cast<ASR::Allocatable_t>(mem_type);

llvm_mem_type = getMemberType(ptr_type->m_type, member, module)->getPointerTo();

break;

}

case ASR::ttypeType::Pointer: {

ASR::Pointer_t* ptr_type = ASR::down_cast<ASR::Pointer_t>(mem_type);

llvm_mem_type = getMemberType(ptr_type->m_type, member, module)->getPointerTo();

break;

}

case ASR::ttypeType::Complex: {

int a_kind = ASR::down_cast<ASR::Complex_t>(mem_type)->m_kind;

llvm_mem_type = getComplexType(a_kind);

break;

}

case ASR::ttypeType::Character: {

llvm_mem_type = character_type;

break;

}

case ASR::ttypeType::CPtr: {

llvm_mem_type = llvm::Type::getVoidTy(context)->getPointerTo();

break;

}

default:

throw CodeGenError("Cannot identify the type of member, '" +

std::string(member->m_name) +

"' in derived type, '" + der_type_name + "'.",

member->base.base.loc);

}

return llvm_mem_type;

}

void LLVMUtils::createStructContext(ASR::StructType_t* der_type) {

std::string der_type_name = std::string(der_type->m_name);

if (name2dercontext.find(der_type_name) == name2dercontext.end() ) {

llvm::StructType* der_type_llvm = llvm::StructType::create(context,

{},

der_type_name,

der_type->m_is_packed);

name2dercontext[der_type_name] = der_type_llvm;

if( der_type->m_parent != nullptr ) {

ASR::StructType_t *par_der_type = ASR::down_cast<ASR::StructType_t>(

ASRUtils::symbol_get_past_external(der_type->m_parent));

createStructContext(par_der_type);

}

for( size_t i = 0; i < der_type->n_members; i++ ) {

std::string member_name = der_type->m_members[i];

ASR::symbol_t* sym = der_type->m_symtab->get_symbol(member_name);

if (ASR::is_a<ASR::StructType_t>(*sym)) {

ASR::StructType_t *d_type = ASR::down_cast<ASR::StructType_t>(sym);

createStructContext(d_type);

}

}

}

}

llvm::Type* LLVMUtils::getStructType(ASR::StructType_t* der_type, llvm::Module* module, bool is_pointer) {

std::string der_type_name = std::string(der_type->m_name);

createStructContext(der_type);

if (std::find(struct_type_stack.begin(), struct_type_stack.end(),

der_type_name) != struct_type_stack.end()) {

LCOMPILERS_ASSERT(name2dercontext.find(der_type_name) != name2dercontext.end());

return name2dercontext[der_type_name];

}

struct_type_stack.push_back(der_type_name);

llvm::StructType** der_type_llvm;

if (name2dertype.find(der_type_name) != name2dertype.end() ) {

der_type_llvm = &name2dertype[der_type_name];

} else {

der_type_llvm = &name2dercontext[der_type_name];

std::vector<llvm::Type*> member_types;

int member_idx = 0;

if( der_type->m_parent != nullptr ) {

ASR::StructType_t *par_der_type = ASR::down_cast<ASR::StructType_t>(

ASRUtils::symbol_get_past_external(der_type->m_parent));

llvm::Type* par_llvm = getStructType(par_der_type, module);

member_types.push_back(par_llvm);

dertype2parent[der_type_name] = std::string(par_der_type->m_name);

member_idx += 1;

}

for( size_t i = 0; i < der_type->n_members; i++ ) {

std::string member_name = der_type->m_members[i];

ASR::Variable_t* member = ASR::down_cast<ASR::Variable_t>(der_type->m_symtab->get_symbol(member_name));

llvm::Type* llvm_mem_type = get_type_from_ttype_t_util(member->m_type, module, member->m_abi);

member_types.push_back(llvm_mem_type);

name2memidx[der_type_name][std::string(member->m_name)] = member_idx;

member_idx++;

}

(*der_type_llvm)->setBody(member_types);

name2dertype[der_type_name] = *der_type_llvm;

}

struct_type_stack.pop_back();

if ( is_pointer ) {

return (*der_type_llvm)->getPointerTo();

}

return (llvm::Type*) *der_type_llvm;

}

llvm::Type* LLVMUtils::getStructType(ASR::ttype_t* _type, llvm::Module* module, bool is_pointer) {

ASR::StructType_t* der_type;

if( ASR::is_a<ASR::Struct_t>(*_type) ) {

ASR::Struct_t* der = ASR::down_cast<ASR::Struct_t>(_type);

ASR::symbol_t* der_sym = ASRUtils::symbol_get_past_external(der->m_derived_type);

der_type = ASR::down_cast<ASR::StructType_t>(der_sym);

} else if( ASR::is_a<ASR::Class_t>(*_type) ) {

ASR::Class_t* der = ASR::down_cast<ASR::Class_t>(_type);

ASR::symbol_t* der_sym = ASRUtils::symbol_get_past_external(der->m_class_type);

der_type = ASR::down_cast<ASR::StructType_t>(der_sym);

} else {

LCOMPILERS_ASSERT(false);

return nullptr; // silence a warning

}

llvm::Type* type = getStructType(der_type, module, is_pointer);

LCOMPILERS_ASSERT(type != nullptr);

return type;

}

llvm::Type* LLVMUtils::getUnionType(ASR::UnionType_t* union_type,

llvm::Module* module, bool is_pointer) {

std::string union_type_name = std::string(union_type->m_name);

llvm::StructType* union_type_llvm = nullptr;

if( name2dertype.find(union_type_name) != name2dertype.end() ) {

union_type_llvm = name2dertype[union_type_name];

} else {

const std::map<std::string, ASR::symbol_t*>& scope = union_type->m_symtab->get_scope();

llvm::DataLayout data_layout(module);

llvm::Type* max_sized_type = nullptr;

size_t max_type_size = 0;

for( auto itr = scope.begin(); itr != scope.end(); itr++ ) {

ASR::Variable_t* member = ASR::down_cast<ASR::Variable_t>(ASRUtils::symbol_get_past_external(itr->second));

llvm::Type* llvm_mem_type = getMemberType(member->m_type, member, module);

size_t type_size = data_layout.getTypeAllocSize(llvm_mem_type);

if( max_type_size < type_size ) {

max_sized_type = llvm_mem_type;

type_size = max_type_size;

}

}

union_type_llvm = llvm::StructType::create(context, {max_sized_type}, union_type_name);

name2dertype[union_type_name] = union_type_llvm;

}

if( is_pointer ) {

return union_type_llvm->getPointerTo();

}

return (llvm::Type*) union_type_llvm;

}

llvm::Type* LLVMUtils::getUnionType(ASR::ttype_t* _type, llvm::Module* module, bool is_pointer) {

ASR::Union_t* union_ = ASR::down_cast<ASR::Union_t>(_type);

ASR::symbol_t* union_sym = ASRUtils::symbol_get_past_external(union_->m_union_type);

ASR::UnionType_t* union_type = ASR::down_cast<ASR::UnionType_t>(union_sym);

return getUnionType(union_type, module, is_pointer);

}

llvm::Type* LLVMUtils::getClassType(ASR::ClassType_t* der_type, bool is_pointer) {

const std::map<std::string, ASR::symbol_t*>& scope = der_type->m_symtab->get_scope();

std::vector<llvm::Type*> member_types;

int member_idx = 0;

for( auto itr = scope.begin(); itr != scope.end(); itr++ ) {

if (!ASR::is_a<ASR::ClassProcedure_t>(*itr->second) &&

!ASR::is_a<ASR::GenericProcedure_t>(*itr->second) &&

!ASR::is_a<ASR::CustomOperator_t>(*itr->second)) {

ASR::Variable_t* member = ASR::down_cast<ASR::Variable_t>(itr->second);

llvm::Type* mem_type = nullptr;

switch( member->m_type->type ) {

case ASR::ttypeType::Integer: {

int a_kind = ASR::down_cast<ASR::Integer_t>(member->m_type)->m_kind;

mem_type = getIntType(a_kind);

break;

}

case ASR::ttypeType::Real: {

int a_kind = ASR::down_cast<ASR::Real_t>(member->m_type)->m_kind;

mem_type = getFPType(a_kind);

break;

}

case ASR::ttypeType::Class: {

mem_type = getClassType(member->m_type);

break;

}

case ASR::ttypeType::Complex: {

int a_kind = ASR::down_cast<ASR::Complex_t>(member->m_type)->m_kind;

mem_type = getComplexType(a_kind);

break;

}

default:

throw CodeGenError("Cannot identify the type of member, '" +

std::string(member->m_name) +

"' in derived type, '" + der_type_name + "'.",

member->base.base.loc);

}

member_types.push_back(mem_type);

name2memidx[der_type_name][std::string(member->m_name)] = member_idx;

member_idx++;

}

}

llvm::StructType* der_type_llvm = llvm::StructType::create(context, member_types, der_type_name);

name2dertype[der_type_name] = der_type_llvm;

if( is_pointer ) {

return der_type_llvm->getPointerTo();

}

return (llvm::Type*) der_type_llvm;

}

llvm::Type* LLVMUtils::getClassType(ASR::StructType_t* der_type, bool is_pointer) {

std::string der_type_name = std::string(der_type->m_name) + std::string("_polymorphic");

llvm::StructType* der_type_llvm = nullptr;

if( name2dertype.find(der_type_name) != name2dertype.end() ) {

der_type_llvm = name2dertype[der_type_name];

}

LCOMPILERS_ASSERT(der_type_llvm != nullptr);

if( is_pointer ) {

return der_type_llvm->getPointerTo();

}

return (llvm::Type*) der_type_llvm;

}

llvm::Type* LLVMUtils::getClassType(ASR::ttype_t* _type, bool is_pointer) {

ASR::Class_t* der = ASR::down_cast<ASR::Class_t>(_type);

ASR::symbol_t* der_sym = ASRUtils::symbol_get_past_external(der->m_class_type);

std::string der_sym_name = ASRUtils::symbol_name(der_sym);

std::string der_type_name = der_sym_name + std::string("_polymorphic");

llvm::StructType* der_type_llvm;

if( name2dertype.find(der_type_name) != name2dertype.end() ) {

der_type_llvm = name2dertype[der_type_name];

} else {

std::vector<llvm::Type*> member_types;

member_types.push_back(getIntType(8));

if( der_sym_name == "~abstract_type" ) {

member_types.push_back(llvm::Type::getVoidTy(context)->getPointerTo());

} else if( ASR::is_a<ASR::ClassType_t>(*der_sym) ) {

ASR::ClassType_t* class_type_t = ASR::down_cast<ASR::ClassType_t>(der_sym);

member_types.push_back(getClassType(class_type_t, is_pointer));

} else if( ASR::is_a<ASR::StructType_t>(*der_sym) ) {

ASR::StructType_t* struct_type_t = ASR::down_cast<ASR::StructType_t>(der_sym);

member_types.push_back(getStructType(struct_type_t, module, is_pointer));

}

der_type_llvm = llvm::StructType::create(context, member_types, der_type_name);

name2dertype[der_type_name] = der_type_llvm;

}

return (llvm::Type*) der_type_llvm;

}

llvm::Type* LLVMUtils::getFPType(int a_kind, bool get_pointer) {

llvm::Type* type_ptr = nullptr;

if( get_pointer ) {

switch(a_kind)

{

case 4:

type_ptr = llvm::Type::getFloatPtrTy(context);

break;

case 8:

type_ptr = llvm::Type::getDoublePtrTy(context);

break;

default:

throw CodeGenError("Only 32 and 64 bits real kinds are supported.");

}

} else {

switch(a_kind)

{

case 4:

type_ptr = llvm::Type::getFloatTy(context);

break;

case 8:

type_ptr = llvm::Type::getDoubleTy(context);

break;

default:

throw CodeGenError("Only 32 and 64 bits real kinds are supported.");

}

}

return type_ptr;

}

llvm::Type* LLVMUtils::getComplexType(int a_kind, bool get_pointer) {

llvm::Type* type = nullptr;

switch(a_kind)

{

case 4:

type = complex_type_4;

break;

case 8:

type = complex_type_8;

break;

default:

throw CodeGenError("Only 32 and 64 bits complex kinds are supported.");

}

if( type != nullptr ) {

if( get_pointer ) {

return type->getPointerTo();

} else {

return type;

}

}

return nullptr;

}

llvm::Type* LLVMUtils::get_el_type(ASR::ttype_t* m_type_, llvm::Module* module) {

int a_kind = ASRUtils::extract_kind_from_ttype_t(m_type_);

llvm::Type* el_type = nullptr;

bool is_pointer = LLVM::is_llvm_pointer(*m_type_);

switch(ASRUtils::type_get_past_pointer(m_type_)->type) {

case ASR::ttypeType::Integer: {

el_type = getIntType(a_kind, is_pointer);

break;

}

case ASR::ttypeType::UnsignedInteger: {

el_type = getIntType(a_kind, is_pointer);

break;

}

case ASR::ttypeType::Real: {

el_type = getFPType(a_kind, is_pointer);

break;

}

case ASR::ttypeType::Complex: {

el_type = getComplexType(a_kind, is_pointer);

break;

}

case ASR::ttypeType::Logical: {

el_type = llvm::Type::getInt1Ty(context);

break;

}

case ASR::ttypeType::Struct: {

el_type = getStructType(m_type_, module);

break;

}

case ASR::ttypeType::Union: {

el_type = getUnionType(m_type_, module);

break;

}

case ASR::ttypeType::Class: {

el_type = getClassType(m_type_);

break;

}

case ASR::ttypeType::Character: {

el_type = character_type;

break;

}

default:

LCOMPILERS_ASSERT(false);

break;

}

return el_type;

}

int32_t get_type_size(ASR::ttype_t* asr_type, llvm::Type* llvm_type,

int32_t a_kind, llvm::Module* module) {

if( LLVM::is_llvm_struct(asr_type) ||

ASR::is_a<ASR::Character_t>(*asr_type) ||

ASR::is_a<ASR::Complex_t>(*asr_type) ) {

llvm::DataLayout data_layout(module);

return data_layout.getTypeAllocSize(llvm_type);

}

return a_kind;

}

llvm::Type* LLVMUtils::get_dict_type(ASR::ttype_t* asr_type, llvm::Module* module) {

ASR::Dict_t* asr_dict = ASR::down_cast<ASR::Dict_t>(asr_type);

bool is_local_array_type = false, is_local_malloc_array_type = false;

bool is_local_list = false;

ASR::dimension_t* local_m_dims = nullptr;

int local_n_dims = 0;

int local_a_kind = -1;

ASR::storage_typeType local_m_storage = ASR::storage_typeType::Default;

llvm::Type* key_llvm_type = get_type_from_ttype_t(asr_dict->m_key_type, nullptr, local_m_storage,

is_local_array_type, is_local_malloc_array_type,

is_local_list, local_m_dims, local_n_dims,

local_a_kind, module);

int32_t key_type_size = get_type_size(asr_dict->m_key_type, key_llvm_type, local_a_kind, module);

llvm::Type* value_llvm_type = get_type_from_ttype_t(asr_dict->m_value_type, nullptr, local_m_storage,

is_local_array_type, is_local_malloc_array_type,

is_local_list, local_m_dims, local_n_dims,

local_a_kind, module);

int32_t value_type_size = get_type_size(asr_dict->m_value_type, value_llvm_type, local_a_kind, module);

std::string key_type_code = ASRUtils::get_type_code(asr_dict->m_key_type);

std::string value_type_code = ASRUtils::get_type_code(asr_dict->m_value_type);

set_dict_api(asr_dict);

return dict_api->get_dict_type(key_type_code, value_type_code, key_type_size,

value_type_size, key_llvm_type, value_llvm_type);

}

llvm::Type* LLVMUtils::get_set_type(ASR::ttype_t* asr_type, llvm::Module* module) {

ASR::Set_t* asr_set = ASR::down_cast<ASR::Set_t>(asr_type);

bool is_local_array_type = false, is_local_malloc_array_type = false;

bool is_local_list = false;

ASR::dimension_t* local_m_dims = nullptr;

int local_n_dims = 0;

int local_a_kind = -1;

ASR::storage_typeType local_m_storage = ASR::storage_typeType::Default;

llvm::Type* el_llvm_type = get_type_from_ttype_t(asr_set->m_type, nullptr, local_m_storage,

is_local_array_type, is_local_malloc_array_type,

is_local_list, local_m_dims, local_n_dims,

local_a_kind, module);

int32_t el_type_size = get_type_size(asr_set->m_type, el_llvm_type, local_a_kind, module);

std::string el_type_code = ASRUtils::get_type_code(asr_set->m_type);

set_set_api(asr_set);

return set_api->get_set_type(el_type_code, el_type_size,

el_llvm_type);

}

llvm::Type* LLVMUtils::get_arg_type_from_ttype_t(ASR::ttype_t* asr_type,

ASR::symbol_t *type_declaration, ASR::abiType m_abi, ASR::abiType arg_m_abi,

ASR::storage_typeType m_storage, bool arg_m_value_attr, int& n_dims,

int& a_kind, bool& is_array_type, ASR::intentType arg_intent, llvm::Module* module,

bool get_pointer) {

llvm::Type* type = nullptr;

#define handle_llvm_pointers2() bool is_pointer_ = ASR::is_a<ASR::Class_t>(*t2) || \

(ASR::is_a<ASR::Character_t>(*t2) && arg_m_abi != ASR::abiType::BindC); \

type = get_arg_type_from_ttype_t(t2, nullptr, m_abi, arg_m_abi, \

m_storage, arg_m_value_attr, n_dims, a_kind, \

is_array_type, arg_intent, module, get_pointer); \

if( !is_pointer_ ) { \

type = type->getPointerTo(); \

} \

switch (asr_type->type) {

case ASR::ttypeType::Array: {

ASR::Array_t* v_type = ASR::down_cast<ASR::Array_t>(asr_type);

switch( v_type->m_physical_type ) {

case ASR::array_physical_typeType::DescriptorArray: {

is_array_type = true;

llvm::Type* el_type = get_el_type(v_type->m_type, module);

type = arr_api->get_array_type(asr_type, el_type, get_pointer);

break;

}

case ASR::array_physical_typeType::PointerToDataArray: {

type = nullptr;

if( ASR::is_a<ASR::Complex_t>(*v_type->m_type) ) {

ASR::Complex_t* complex_t = ASR::down_cast<ASR::Complex_t>(v_type->m_type);

type = getComplexType(complex_t->m_kind, true);

}

if( type == nullptr ) {

type = get_type_from_ttype_t_util(v_type->m_type, module, arg_m_abi)->getPointerTo();

}

break;

}

case ASR::array_physical_typeType::UnboundedPointerToDataArray: {

type = nullptr;

if( ASR::is_a<ASR::Complex_t>(*v_type->m_type) ) {

ASR::Complex_t* complex_t = ASR::down_cast<ASR::Complex_t>(v_type->m_type);

type = getComplexType(complex_t->m_kind, true);

}

if( type == nullptr ) {

type = get_type_from_ttype_t_util(v_type->m_type, module, arg_m_abi)->getPointerTo();

}

break;

}

case ASR::array_physical_typeType::FixedSizeArray: {

type = llvm::ArrayType::get(get_el_type(v_type->m_type, module),

ASRUtils::get_fixed_size_of_array(

v_type->m_dims, v_type->n_dims))->getPointerTo();

break;

}

default: {

LCOMPILERS_ASSERT(false);

}

}

break;

}

case (ASR::ttypeType::Integer) : {

ASR::Integer_t* v_type = ASR::down_cast<ASR::Integer_t>(asr_type);

a_kind = v_type->m_kind;

if (arg_m_abi == ASR::abiType::BindC

&& arg_m_value_attr) {

type = getIntType(a_kind, false);

} else {

type = getIntType(a_kind, true);

}

break;

}

case (ASR::ttypeType::UnsignedInteger) : {

ASR::UnsignedInteger_t* v_type = ASR::down_cast<ASR::UnsignedInteger_t>(asr_type);

a_kind = v_type->m_kind;

if (arg_m_abi == ASR::abiType::BindC

&& arg_m_value_attr) {

type = getIntType(a_kind, false);

} else {

type = getIntType(a_kind, true);

}

break;

}

case (ASR::ttypeType::Pointer) : {

ASR::ttype_t *t2 = ASRUtils::type_get_past_pointer(asr_type);

handle_llvm_pointers2()

break;

}

case (ASR::ttypeType::Allocatable) : {

ASR::ttype_t *t2 = ASRUtils::type_get_past_allocatable(asr_type);

handle_llvm_pointers2()

break;

}

case (ASR::ttypeType::Const) : {

ASR::ttype_t *t2 = ASRUtils::get_contained_type(asr_type);

type = get_arg_type_from_ttype_t(t2, nullptr, m_abi, arg_m_abi,

m_storage, arg_m_value_attr, n_dims, a_kind,

is_array_type, arg_intent, module, get_pointer);

break;

}

case (ASR::ttypeType::Real) : {

ASR::Real_t* v_type = ASR::down_cast<ASR::Real_t>(asr_type);

a_kind = v_type->m_kind;

if (arg_m_abi == ASR::abiType::BindC

&& arg_m_value_attr) {

type = getFPType(a_kind, false);

} else {

type = getFPType(a_kind, true);

}

break;

}

case (ASR::ttypeType::Complex) : {

ASR::Complex_t* v_type = ASR::down_cast<ASR::Complex_t>(asr_type);

a_kind = v_type->m_kind;

if (m_abi != ASR::abiType::BindC) {

type = getComplexType(a_kind, true);

} else {

if (arg_m_abi == ASR::abiType::BindC

&& arg_m_value_attr) {

if (a_kind == 4) {

if (compiler_options.platform == Platform::Windows) {

// type_fx2 is i64

llvm::Type* type_fx2 = llvm::Type::getInt64Ty(context);

type = type_fx2;

} else if (compiler_options.platform == Platform::macOS_ARM) {

// type_fx2 is [2 x float]

llvm::Type* type_fx2 = llvm::ArrayType::get(llvm::Type::getFloatTy(context), 2);

type = type_fx2;

} else {

// type_fx2 is <2 x float>

llvm::Type* type_fx2 = FIXED_VECTOR_TYPE::get(llvm::Type::getFloatTy(context), 2);

type = type_fx2;

}

} else {

LCOMPILERS_ASSERT(a_kind == 8)

if (compiler_options.platform == Platform::Windows) {

// 128 bit aggregate type is passed by reference

type = getComplexType(a_kind, true);

} else {

// Pass by value

type = getComplexType(a_kind, false);

}

}

} else {

type = getComplexType(a_kind, true);

}

}

break;

}

case (ASR::ttypeType::Character) : {

ASR::Character_t* v_type = ASR::down_cast<ASR::Character_t>(asr_type);

a_kind = v_type->m_kind;

if (arg_m_abi == ASR::abiType::BindC) {

type = character_type;

} else {

type = character_type->getPointerTo();

}

break;

}

case (ASR::ttypeType::Logical) : {

ASR::Logical_t* v_type = ASR::down_cast<ASR::Logical_t>(asr_type);

a_kind = v_type->m_kind;

if (arg_m_abi == ASR::abiType::BindC

&& arg_m_value_attr) {

type = llvm::Type::getInt1Ty(context);

} else {

type = llvm::Type::getInt1PtrTy(context);

}

break;

}

case (ASR::ttypeType::Struct) : {

type = getStructType(asr_type, module, true);

break;

}

case (ASR::ttypeType::Class) : {

type = getClassType(asr_type, true)->getPointerTo();

break;

}

case (ASR::ttypeType::CPtr) : {

type = llvm::Type::getVoidTy(context)->getPointerTo();

break;

}

case (ASR::ttypeType::Tuple) : {

type = get_type_from_ttype_t_util(asr_type, module)->getPointerTo();

break;

}

case (ASR::ttypeType::List) : {

bool is_array_type = false, is_malloc_array_type = false;

bool is_list = true;

ASR::dimension_t *m_dims = nullptr;

ASR::List_t* asr_list = ASR::down_cast<ASR::List_t>(asr_type);

llvm::Type* el_llvm_type = get_type_from_ttype_t(asr_list->m_type, nullptr, m_storage,

is_array_type,

is_malloc_array_type,

is_list, m_dims, n_dims,

a_kind, module, m_abi);

int32_t type_size = -1;

if( LLVM::is_llvm_struct(asr_list->m_type) ||

ASR::is_a<ASR::Character_t>(*asr_list->m_type) ||

ASR::is_a<ASR::Complex_t>(*asr_list->m_type) ) {

llvm::DataLayout data_layout(module);

type_size = data_layout.getTypeAllocSize(el_llvm_type);

} else {

type_size = a_kind;

}

std::string el_type_code = ASRUtils::get_type_code(asr_list->m_type);

type = list_api->get_list_type(el_llvm_type, el_type_code, type_size)->getPointerTo();

break;

}

case ASR::ttypeType::Enum: {

if (arg_m_abi == ASR::abiType::BindC

&& arg_m_value_attr) {

type = llvm::Type::getInt32Ty(context);

} else {

type = llvm::Type::getInt32PtrTy(context);

}

break ;

}

case (ASR::ttypeType::Dict): {

ASR::Dict_t* asr_dict = ASR::down_cast<ASR::Dict_t>(asr_type);

std::string key_type_code = ASRUtils::get_type_code(asr_dict->m_key_type);

std::string value_type_code = ASRUtils::get_type_code(asr_dict->m_value_type);

bool is_array_type = false, is_malloc_array_type = false;

bool is_list = false;

ASR::dimension_t* m_dims = nullptr;

llvm::Type* key_llvm_type = get_type_from_ttype_t(asr_dict->m_key_type, type_declaration, m_storage,

is_array_type,

is_malloc_array_type,

is_list, m_dims, n_dims,

a_kind, module, m_abi);

llvm::Type* value_llvm_type = get_type_from_ttype_t(asr_dict->m_value_type, type_declaration, m_storage,

is_array_type,

is_malloc_array_type,

is_list, m_dims, n_dims,

a_kind, module, m_abi);

int32_t key_type_size = get_type_size(asr_dict->m_key_type, key_llvm_type, a_kind, module);

int32_t value_type_size = get_type_size(asr_dict->m_value_type, value_llvm_type, a_kind, module);

set_dict_api(asr_dict);

type = dict_api->get_dict_type(key_type_code, value_type_code,

key_type_size, value_type_size,

key_llvm_type, value_llvm_type)->getPointerTo();

break;

}

case (ASR::ttypeType::Set): {

ASR::Set_t* asr_set = ASR::down_cast<ASR::Set_t>(asr_type);

std::string el_type_code = ASRUtils::get_type_code(asr_set->m_type);

bool is_array_type = false, is_malloc_array_type = false;

bool is_list = false;

ASR::dimension_t* m_dims = nullptr;

llvm::Type* el_llvm_type = get_type_from_ttype_t(asr_set->m_type, type_declaration, m_storage,

is_array_type,

is_malloc_array_type,

is_list, m_dims, n_dims,

a_kind, module, m_abi);

int32_t el_type_size = get_type_size(asr_set->m_type, el_llvm_type, a_kind, module);

set_set_api(asr_set);

type = set_api->get_set_type(el_type_code, el_type_size, el_llvm_type)->getPointerTo();

break;

}

case ASR::ttypeType::FunctionType: {

ASR::Function_t* fn = ASR::down_cast<ASR::Function_t>(

ASRUtils::symbol_get_past_external(type_declaration));

type = get_function_type(*fn, module)->getPointerTo();

break ;

}

default :

LCOMPILERS_ASSERT(false);

}

return type;

}

void LLVMUtils::set_dict_api(ASR::Dict_t* dict_type) {

if( ASR::is_a<ASR::Character_t>(*dict_type->m_key_type) ) {

dict_api = dict_api_sc;

} else {

dict_api = dict_api_lp;

}

}

void LLVMUtils::set_set_api(ASR::Set_t* /*set_type*/) {

// As per benchmarks, separate chaining

// does not provide significant gains over

// linear probing.

set_api = set_api_lp;

}

std::vector<llvm::Type*> LLVMUtils::convert_args(const ASR::Function_t& x, llvm::Module* module) {

std::vector<llvm::Type*> args;

for (size_t i=0; i<x.n_args; i++) {

if (ASR::is_a<ASR::Variable_t>(*ASRUtils::symbol_get_past_external(

ASR::down_cast<ASR::Var_t>(x.m_args[i])->m_v))) {

ASR::Variable_t *arg = ASRUtils::EXPR2VAR(x.m_args[i]);

LCOMPILERS_ASSERT(ASRUtils::is_arg_dummy(arg->m_intent));

// We pass all arguments as pointers for now,

// except bind(C) value arguments that are passed by value

llvm::Type *type = nullptr, *type_original = nullptr;

int n_dims = 0, a_kind = 4;

bool is_array_type = false;

type_original = get_arg_type_from_ttype_t(arg->m_type,

arg->m_type_declaration,

ASRUtils::get_FunctionType(x)->m_abi,

arg->m_abi, arg->m_storage, arg->m_value_attr,

n_dims, a_kind, is_array_type, arg->m_intent,

module, false);

if( is_array_type ) {

type = type_original->getPointerTo();

} else {

type = type_original;

}

if( arg->m_intent == ASRUtils::intent_out &&

ASR::is_a<ASR::CPtr_t>(*arg->m_type) ) {

type = type->getPointerTo();

}

std::uint32_t m_h;

std::string m_name = std::string(x.m_name);

if( x.class_type == ASR::symbolType::Function ) {

ASR::Function_t* _func = (ASR::Function_t*)(&(x.base));

m_h = get_hash((ASR::asr_t*)_func);

}

if( is_array_type && !LLVM::is_llvm_pointer(*arg->m_type) ) {

if( ASRUtils::get_FunctionType(x)->m_abi == ASR::abiType::Source ) {

llvm::Type* orig_type = type_original;

type = arr_api->get_argument_type(orig_type, m_h, arg->m_name, arr_arg_type_cache);

is_array_type = false;

} else if( ASRUtils::get_FunctionType(x)->m_abi == ASR::abiType::Intrinsic &&

fname2arg_type.find(m_name) != fname2arg_type.end()) {

type = fname2arg_type[m_name].second;

is_array_type = false;

}

}

args.push_back(type);

} else if (ASR::is_a<ASR::Function_t>(*ASRUtils::symbol_get_past_external(

ASR::down_cast<ASR::Var_t>(x.m_args[i])->m_v))) {

/* This is likely a procedure passed as an argument. For the

type, we need to pass in a function pointer with the

correct call signature. */

ASR::Function_t* fn = ASR::down_cast<ASR::Function_t>(

ASRUtils::symbol_get_past_external(ASR::down_cast<ASR::Var_t>(

x.m_args[i])->m_v));

llvm::Type* type = get_function_type(*fn, module)->getPointerTo();

args.push_back(type);

} else {

throw CodeGenError("Argument type not implemented");

}

}

return args;

}

llvm::FunctionType* LLVMUtils::get_function_type(const ASR::Function_t &x, llvm::Module* module) {

llvm::Type *return_type;

if (x.m_return_var) {

ASR::ttype_t *return_var_type0 = ASRUtils::EXPR2VAR(x.m_return_var)->m_type;

ASR::ttypeType return_var_type = return_var_type0->type;

switch (return_var_type) {

case (ASR::ttypeType::Integer) : {

int a_kind = ASR::down_cast<ASR::Integer_t>(return_var_type0)->m_kind;

return_type = getIntType(a_kind);

break;

}

case (ASR::ttypeType::UnsignedInteger) : {

int a_kind = ASR::down_cast<ASR::UnsignedInteger_t>(return_var_type0)->m_kind;

return_type = getIntType(a_kind);

break;

}

case (ASR::ttypeType::Real) : {

int a_kind = ASR::down_cast<ASR::Real_t>(return_var_type0)->m_kind;

return_type = getFPType(a_kind);

break;

}

case (ASR::ttypeType::Complex) : {

int a_kind = ASR::down_cast<ASR::Complex_t>(return_var_type0)->m_kind;

if (a_kind == 4) {

if (ASRUtils::get_FunctionType(x)->m_abi == ASR::abiType::BindC) {

if (compiler_options.platform == Platform::Windows) {

// i64

return_type = llvm::Type::getInt64Ty(context);

} else if (compiler_options.platform == Platform::macOS_ARM) {

// {float, float}

return_type = getComplexType(a_kind);

} else {

// <2 x float>

return_type = FIXED_VECTOR_TYPE::get(llvm::Type::getFloatTy(context), 2);

}

} else {

return_type = getComplexType(a_kind);

}

} else {

LCOMPILERS_ASSERT(a_kind == 8)

if (ASRUtils::get_FunctionType(x)->m_abi == ASR::abiType::BindC) {

if (compiler_options.platform == Platform::Windows) {

// pass as subroutine

return_type = getComplexType(a_kind, true);

std::vector<llvm::Type*> args = convert_args(x, module);

args.insert(args.begin(), return_type);

llvm::FunctionType *function_type = llvm::FunctionType::get(

llvm::Type::getVoidTy(context), args, false);

return function_type;

} else {

return_type = getComplexType(a_kind);

}

} else {

return_type = getComplexType(a_kind);

}

}

break;

}

case (ASR::ttypeType::Character) :

return_type = character_type;

break;

case (ASR::ttypeType::Logical) :

return_type = llvm::Type::getInt1Ty(context);

break;

case (ASR::ttypeType::CPtr) :

return_type = llvm::Type::getVoidTy(context)->getPointerTo();

break;

case (ASR::ttypeType::Const) : {

return_type = get_type_from_ttype_t_util(ASRUtils::get_contained_type(return_var_type0), module);

break;

}

case (ASR::ttypeType::Pointer) : {

return_type = get_type_from_ttype_t_util(ASRUtils::get_contained_type(return_var_type0), module)->getPointerTo();

break;

}

case (ASR::ttypeType::Allocatable) : {