F2C: DeReferenceTrafo

loki/backend/cgen.py

@@ -352,7 +352,7 @@ def visit_CallStatement(self, o, **kwargs):
         """
         args = self.visit_all(o.arguments, **kwargs)
         assert not o.kwarguments
-        return self.format_line(o.name, '(', self.join_items(args), ');')
+        return self.format_line(str(o.name), '(', self.join_items(args), ');')
 
     def visit_SymbolAttributes(self, o, **kwargs):  # pylint: disable=unused-argument
         if isinstance(o.dtype, DerivedType):

loki/transform/fortran_c_transform.py

@@ -31,7 +31,8 @@
 from loki.module import Module
 from loki.expression import (
     Variable, InlineCall, RangeIndex, Scalar, Array,
-    ProcedureSymbol, SubstituteExpressions, Dereference,
+    ProcedureSymbol, SubstituteExpressions, Dereference, Reference,
+    ExpressionRetriever, SubstituteExpressionsMapper,
 )
 from loki.expression import symbols as sym
 from loki.tools import as_tuple, flatten
@@ -477,17 +478,51 @@ def generate_c_kernel(self, routine):
         convert_to_lower_case(kernel)
 
         # Force pointer on reference-passed arguments
-        var_map = {}
+        to_be_dereferenced = []
         for arg in kernel.arguments:
             if not(arg.type.intent.lower() == 'in' and isinstance(arg, Scalar)):
                 _type = arg.type.clone(pointer=True)
                 if isinstance(arg.type.dtype, DerivedType):
                     # Lower case type names for derived types
                     typedef = _type.dtype.typedef.clone(name=_type.dtype.typedef.name.lower())
                     _type = _type.clone(dtype=typedef.dtype)
-                var_map[arg] = Dereference(arg)
+                to_be_dereferenced.append(arg.name.lower())
                 kernel.symbol_attrs[arg.name] = _type
-        kernel.body = SubstituteExpressions(var_map).visit(kernel.body)
+
+        class DeReferenceTrafo(Transformer):
+
+            def __init__(self, vars2dereference):
+                super().__init__()
+                self.retriever = ExpressionRetriever(lambda e: isinstance(e, (DerivedType, Array, Scalar))\
+                        and e.name.lower() in vars2dereference)
+
+            def visit_Expression(self, o, **kwargs):
+                symbols = self.retriever.retrieve(o)
+                symbol_map = {}
+                for symbol in symbols:
+                    if isinstance(symbol, Array) and symbol.dimensions is not None\
+                            and not all(dim == sym.RangeIndex((None, None)) for dim in symbol.dimensions):
+                        continue
+                    symbol_map[symbol] = Dereference(symbol.clone())
+                return SubstituteExpressionsMapper(symbol_map)(o)
+
+            def visit_CallStatement(self, o, **kwargs):
+                new_args = ()
+                call_arg_map = dict((v,k) for k,v in o.arg_map.items())
+                for arg in o.arguments:
+                    if isinstance(arg, Array) and arg.dimensions\
+                            and all(dim != sym.RangeIndex((None, None)) for dim in arg.dimensions) \
+                            and (isinstance(call_arg_map[arg], Array) or call_arg_map[arg].type.intent.lower() != 'in'):
+                        new_args += (Reference(arg.clone()),)
+                    else:
+                        if isinstance(arg, Scalar) and call_arg_map[arg].type.intent.lower() != 'in':
+                            new_args += (Reference(arg.clone()),)
+                        else:
+                            new_args += (arg,)
+                o._update(arguments=new_args)
+                return o
+
+        kernel.body = DeReferenceTrafo(to_be_dereferenced).visit(kernel.body)
 
         symbol_map = {'epsilon': 'DBL_EPSILON'}
         function_map = {'min': 'fmin', 'max': 'fmax', 'abs': 'fabs',

tests/test_transpile.py

@@ -1004,6 +1004,60 @@ def test_transpile_expressions(here, builder, frontend, use_c_ptr):
     f2c.wrapperpath.unlink()
     f2c.c_path.unlink()
 
+
+@pytest.mark.parametrize('use_c_ptr', (False, True))
+@pytest.mark.parametrize('frontend', available_frontends())
+def test_transpile_call(here, frontend, use_c_ptr):
+    fcode_module = """
+module transpile_call_kernel_mod
+  implicit none
+contains
+
+  subroutine transpile_call_kernel(a, b, c, arr1, len)
+    integer, intent(inout) :: a, c
+    integer, intent(in) :: b
+    integer, intent(in) :: len
+    integer, intent(inout) :: arr1(len, len)
+    a = b
+    c = b
+  end subroutine transpile_call_kernel
+end module transpile_call_kernel_mod
+"""
+
+    fcode = """
+subroutine transpile_call_driver(a)
+  use transpile_call_kernel_mod, only: transpile_call_kernel
+    integer, intent(inout) :: a
+    integer, parameter :: len = 5
+    integer :: arr1(len, len)
+    integer :: arr2(len, len)
+    integer :: b
+    b = 2 * len
+    call transpile_call_kernel(a, b, arr2(1, 1), arr1, len)
+end subroutine transpile_call_driver
+"""
+    unlink_paths = []
+    module = Module.from_source(fcode_module, frontend=frontend)
+    routine = Subroutine.from_source(fcode, frontend=frontend, definitions=module)
+    f2c = FortranCTransformation(use_c_ptr=use_c_ptr, path=here)
+    f2c.apply(source=module.subroutine_map['transpile_call_kernel'], path=here, role='kernel')
+    unlink_paths.extend([f2c.wrapperpath, f2c.c_path])
+    ccode_kernel = f2c.c_path.read_text().replace(' ', '').replace('\n', '')
+    f2c.apply(source=routine, path=here, role='kernel')
+    unlink_paths.extend([f2c.wrapperpath, f2c.c_path])
+    ccode_driver = f2c.c_path.read_text().replace(' ', '').replace('\n', '')
+
+    assert "int*a,intb,int*c" in ccode_kernel
+    # check for applied Dereference
+    assert "(*a)=b;" in ccode_kernel
+    assert "(*c)=b;" in ccode_kernel
+    # check for applied Reference
+    assert "transpile_call_kernel((&a),b,(&arr2[" in ccode_driver
+
+    for path in unlink_paths:
+        path.unlink()
+
+
 @pytest.mark.parametrize('frontend', available_frontends())
 def test_transpile_multiconditional(here, builder, frontend):
     """