compiler: Merge `maybenull` and `maybe_null`

[nit.git] / src / compiler / separate_compiler.nit

diff --git a/src/compiler/separate_compiler.nit b/src/compiler/separate_compiler.nit
index 532b844..45790b3 100644 (file)
--- a/src/compiler/separate_compiler.nit
+++ b/src/compiler/separate_compiler.nit
@@ -26,20 +26,20 @@ redef class ToolContext
        # --no-inline-intern
        var opt_no_inline_intern = new OptionBool("Do not inline call to intern methods", "--no-inline-intern")
        # --no-union-attribute
        # --no-inline-intern
        var opt_no_inline_intern = new OptionBool("Do not inline call to intern methods", "--no-inline-intern")
        # --no-union-attribute

-       var opt_no_union_attribute = new OptionBool("Put primitive attibutes in a box instead of an union", "--no-union-attribute")
+       var opt_no_union_attribute = new OptionBool("Put primitive attributes in a box instead of an union", "--no-union-attribute")

        # --no-shortcut-equate
        var opt_no_shortcut_equate = new OptionBool("Always call == in a polymorphic way", "--no-shortcut-equal")
        # --no-tag-primitives
        var opt_no_tag_primitives = new OptionBool("Use only boxes for primitive types", "--no-tag-primitives")
 
        # --colors-are-symbols
        # --no-shortcut-equate
        var opt_no_shortcut_equate = new OptionBool("Always call == in a polymorphic way", "--no-shortcut-equal")
        # --no-tag-primitives
        var opt_no_tag_primitives = new OptionBool("Use only boxes for primitive types", "--no-tag-primitives")
 
        # --colors-are-symbols

-       var opt_colors_are_symbols = new OptionBool("Store colors as symbols (link-boost)", "--colors-are-symbols")
+       var opt_colors_are_symbols = new OptionBool("Store colors as symbols instead of static data (link-boost)", "--colors-are-symbols")

        # --trampoline-call
        var opt_trampoline_call = new OptionBool("Use an indirection when calling", "--trampoline-call")
        # --guard-call
        var opt_guard_call = new OptionBool("Guard VFT calls with a direct call", "--guard-call")
        # --substitute-monomorph
        # --trampoline-call
        var opt_trampoline_call = new OptionBool("Use an indirection when calling", "--trampoline-call")
        # --guard-call
        var opt_guard_call = new OptionBool("Guard VFT calls with a direct call", "--guard-call")
        # --substitute-monomorph

-       var opt_substitute_monomorph = new OptionBool("Replace monomorph trampoline with direct call (link-boost)", "--substitute-monomorph")
+       var opt_substitute_monomorph = new OptionBool("Replace monomorphic trampolines with direct calls (link-boost)", "--substitute-monomorph")

        # --link-boost
        var opt_link_boost = new OptionBool("Enable all link-boost optimizations", "--link-boost")
 
        # --link-boost
        var opt_link_boost = new OptionBool("Enable all link-boost optimizations", "--link-boost")
 

@@ -48,9 +48,9 @@ redef class ToolContext
        # --inline-some-methods
        var opt_inline_some_methods = new OptionBool("Allow the separate compiler to inline some methods (semi-global)", "--inline-some-methods")
        # --direct-call-monomorph
        # --inline-some-methods
        var opt_inline_some_methods = new OptionBool("Allow the separate compiler to inline some methods (semi-global)", "--inline-some-methods")
        # --direct-call-monomorph

-       var opt_direct_call_monomorph = new OptionBool("Allow the separate compiler to direct call monomorph sites (semi-global)", "--direct-call-monomorph")
+       var opt_direct_call_monomorph = new OptionBool("Allow the separate compiler to direct call monomorphic sites (semi-global)", "--direct-call-monomorph")

        # --direct-call-monomorph0
        # --direct-call-monomorph0

-       var opt_direct_call_monomorph0 = new OptionBool("Allow the separate compiler to direct call monomorph sites (semi-global)", "--direct-call-monomorph0")
+       var opt_direct_call_monomorph0 = new OptionBool("Allow the separate compiler to direct call monomorphic sites (semi-global)", "--direct-call-monomorph0")

        # --skip-dead-methods
        var opt_skip_dead_methods = new OptionBool("Do not compile dead methods (semi-global)", "--skip-dead-methods")
        # --semi-global
        # --skip-dead-methods
        var opt_skip_dead_methods = new OptionBool("Do not compile dead methods (semi-global)", "--skip-dead-methods")
        # --semi-global

@@ -60,7 +60,7 @@ redef class ToolContext
        # --tables-metrics
        var opt_tables_metrics = new OptionBool("Enable static size measuring of tables used for vft, typing and resolution", "--tables-metrics")
        # --type-poset
        # --tables-metrics
        var opt_tables_metrics = new OptionBool("Enable static size measuring of tables used for vft, typing and resolution", "--tables-metrics")
        # --type-poset

-       var opt_type_poset = new OptionBool("Build a poset of types to create more condensed tables.", "--type-poset")
+       var opt_type_poset = new OptionBool("Build a poset of types to create more condensed tables", "--type-poset")

 
        redef init
        do
 
        redef init
        do

@@ -252,11 +252,11 @@ class SeparateCompiler
        do
                # Collect all bas box class
                # FIXME: this is not completely fine with a separate compilation scheme
        do
                # Collect all bas box class
                # FIXME: this is not completely fine with a separate compilation scheme

-               for classname in ["Int", "Bool", "Byte", "Char", "Float", "NativeString",
+               for classname in ["Int", "Bool", "Byte", "Char", "Float", "CString",

                                 "Pointer", "Int8", "Int16", "UInt16", "Int32", "UInt32"] do
                        var classes = self.mainmodule.model.get_mclasses_by_name(classname)
                        if classes == null then continue
                                 "Pointer", "Int8", "Int16", "UInt16", "Int32", "UInt32"] do
                        var classes = self.mainmodule.model.get_mclasses_by_name(classname)
                        if classes == null then continue

-                       assert classes.length == 1 else print classes.join(", ")
+                       assert classes.length == 1 else print_error classes.join(", ")

                        self.box_kinds[classes.first] = self.box_kinds.length + 1
                end
        end
                        self.box_kinds[classes.first] = self.box_kinds.length + 1
                end
        end

@@ -269,7 +269,7 @@ class SeparateCompiler
                #if mclass.mclass_type.ctype == "val*" or mclass.mclass_type.is_subtype(self.mainmodule, mclass.mclass_type pointer_type) then
                if mclass.mclass_type.ctype_extern == "val*" then
                        return 0
                #if mclass.mclass_type.ctype == "val*" or mclass.mclass_type.is_subtype(self.mainmodule, mclass.mclass_type pointer_type) then
                if mclass.mclass_type.ctype_extern == "val*" then
                        return 0

-               else if mclass.kind == extern_kind and mclass.name != "NativeString" then
+               else if mclass.kind == extern_kind and mclass.name != "CString" then

                        return self.box_kinds[self.mainmodule.pointer_type.mclass]
                else
                        return self.box_kinds[mclass]
                        return self.box_kinds[self.mainmodule.pointer_type.mclass]
                else
                        return self.box_kinds[mclass]

@@ -626,7 +626,7 @@ class SeparateCompiler
                for cd in mmodule.mclassdefs do
                        for pd in cd.mpropdefs do
                                if not pd isa MMethodDef then continue
                for cd in mmodule.mclassdefs do
                        for pd in cd.mpropdefs do
                                if not pd isa MMethodDef then continue

-                               if pd.msignature == null then continue # Skip broken method
+                               if pd.mproperty.is_broken or pd.is_broken or pd.msignature == null then continue # Skip broken method

                                var rta = runtime_type_analysis
                                if modelbuilder.toolcontext.opt_skip_dead_methods.value and rta != null and not rta.live_methoddefs.has(pd) then continue
                                #print "compile {pd} @ {cd} @ {mmodule}"
                                var rta = runtime_type_analysis
                                if modelbuilder.toolcontext.opt_skip_dead_methods.value and rta != null and not rta.live_methoddefs.has(pd) then continue
                                #print "compile {pd} @ {cd} @ {mmodule}"

@@ -814,6 +814,8 @@ class SeparateCompiler
        # In a true separate compiler (a with dynamic loading) you cannot do this unfortnally
        fun compile_class_to_c(mclass: MClass)
        do
        # In a true separate compiler (a with dynamic loading) you cannot do this unfortnally
        fun compile_class_to_c(mclass: MClass)
        do

+               if mclass.is_broken then return
+

                var mtype = mclass.intro.bound_mtype
                var c_name = mclass.c_name
 
                var mtype = mclass.intro.bound_mtype
                var c_name = mclass.c_name
 

@@ -843,6 +845,9 @@ class SeparateCompiler
                                        if rta != null and not rta.live_methoddefs.has(mpropdef) then
                                                v.add_decl("NULL, /* DEAD {mclass.intro_mmodule}:{mclass}:{mpropdef} */")
                                                continue
                                        if rta != null and not rta.live_methoddefs.has(mpropdef) then
                                                v.add_decl("NULL, /* DEAD {mclass.intro_mmodule}:{mclass}:{mpropdef} */")
                                                continue

+                                       else if mpropdef.is_broken or mpropdef.msignature == null or mpropdef.mproperty.is_broken then
+                                               v.add_decl("NULL, /* DEAD (BROKEN) {mclass.intro_mmodule}:{mclass}:{mpropdef} */")
+                                               continue

                                        end
                                        var rf = mpropdef.virtual_runtime_function
                                        v.require_declaration(rf.c_name)
                                        end
                                        var rf = mpropdef.virtual_runtime_function
                                        v.require_declaration(rf.c_name)

@@ -872,7 +877,8 @@ class SeparateCompiler
                        self.provide_declaration("BOX_{c_name}", "val* BOX_{c_name}({mtype.ctype_extern});")
                        v.add_decl("/* allocate {mtype} */")
                        v.add_decl("val* BOX_{mtype.c_name}({mtype.ctype_extern} value) \{")
                        self.provide_declaration("BOX_{c_name}", "val* BOX_{c_name}({mtype.ctype_extern});")
                        v.add_decl("/* allocate {mtype} */")
                        v.add_decl("val* BOX_{mtype.c_name}({mtype.ctype_extern} value) \{")

-                       v.add("struct instance_{c_name}*res = nit_alloc(sizeof(struct instance_{c_name}));")
+                       var alloc = v.nit_alloc("sizeof(struct instance_{c_name})", mclass.full_name)
+                       v.add("struct instance_{c_name}*res = {alloc};")

                        v.compiler.undead_types.add(mtype)
                        v.require_declaration("type_{c_name}")
                        v.add("res->type = &type_{c_name};")
                        v.compiler.undead_types.add(mtype)
                        v.require_declaration("type_{c_name}")
                        v.add("res->type = &type_{c_name};")

@@ -894,7 +900,8 @@ class SeparateCompiler
                        else
                                var res = v.new_named_var(mtype, "self")
                                res.is_exact = true
                        else
                                var res = v.new_named_var(mtype, "self")
                                res.is_exact = true

-                               v.add("{res} = nit_alloc(sizeof(struct instance_{mtype.c_name}));")
+                               alloc = v.nit_alloc("sizeof(struct instance_{mtype.c_name})", mclass.full_name)
+                               v.add("{res} = {alloc};")

                                v.add("{res}->type = type;")
                                hardening_live_type(v, "type")
                                v.require_declaration("class_{c_name}")
                                v.add("{res}->type = type;")
                                hardening_live_type(v, "type")
                                v.require_declaration("class_{c_name}")

@@ -921,7 +928,8 @@ class SeparateCompiler
                        var res = v.get_name("self")
                        v.add_decl("struct instance_{c_name} *{res};")
                        var mtype_elt = mtype.arguments.first
                        var res = v.get_name("self")
                        v.add_decl("struct instance_{c_name} *{res};")
                        var mtype_elt = mtype.arguments.first

-                       v.add("{res} = nit_alloc(sizeof(struct instance_{c_name}) + length*sizeof({mtype_elt.ctype}));")
+                       var alloc = v.nit_alloc("sizeof(struct instance_{c_name}) + length*sizeof({mtype_elt.ctype})", mclass.full_name)
+                       v.add("{res} = {alloc};")

                        v.add("{res}->type = type;")
                        hardening_live_type(v, "type")
                        v.require_declaration("class_{c_name}")
                        v.add("{res}->type = type;")
                        hardening_live_type(v, "type")
                        v.require_declaration("class_{c_name}")

@@ -930,9 +938,9 @@ class SeparateCompiler
                        v.add("return (val*){res};")
                        v.add("\}")
                        return
                        v.add("return (val*){res};")
                        v.add("\}")
                        return

-               else if mtype.mclass.kind == extern_kind and mtype.mclass.name != "NativeString" then
-                       # Is an extern class (other than Pointer and NativeString)
-                       # Pointer is caught in a previous `if`, and NativeString is internal
+               else if mtype.mclass.kind == extern_kind and mtype.mclass.name != "CString" then
+                       # Is an extern class (other than Pointer and CString)
+                       # Pointer is caught in a previous `if`, and CString is internal

 
                        var pointer_type = mainmodule.pointer_type
 
 
                        var pointer_type = mainmodule.pointer_type
 

@@ -944,7 +952,8 @@ class SeparateCompiler
                        else
                                var res = v.new_named_var(mtype, "self")
                                res.is_exact = true
                        else
                                var res = v.new_named_var(mtype, "self")
                                res.is_exact = true

-                               v.add("{res} = nit_alloc(sizeof(struct instance_{pointer_type.c_name}));")
+                               var alloc = v.nit_alloc("sizeof(struct instance_{pointer_type.c_name})", mclass.full_name)
+                               v.add("{res} = {alloc};")

                                v.add("{res}->type = type;")
                                hardening_live_type(v, "type")
                                v.require_declaration("class_{c_name}")
                                v.add("{res}->type = type;")
                                hardening_live_type(v, "type")
                                v.require_declaration("class_{c_name}")

@@ -967,9 +976,11 @@ class SeparateCompiler
                        res.is_exact = true
                        var attrs = self.attr_tables.get_or_null(mclass)
                        if attrs == null then
                        res.is_exact = true
                        var attrs = self.attr_tables.get_or_null(mclass)
                        if attrs == null then

-                               v.add("{res} = nit_alloc(sizeof(struct instance));")
+                               var alloc = v.nit_alloc("sizeof(struct instance)", mclass.full_name)
+                               v.add("{res} = {alloc};")

                        else
                        else

-                               v.add("{res} = nit_alloc(sizeof(struct instance) + {attrs.length}*sizeof(nitattribute_t));")
+                               var alloc = v.nit_alloc("sizeof(struct instance) + {attrs.length}*sizeof(nitattribute_t)", mclass.full_name)
+                               v.add("{res} = {alloc};")

                        end
                        v.add("{res}->type = type;")
                        hardening_live_type(v, "type")
                        end
                        v.add("{res}->type = type;")
                        hardening_live_type(v, "type")

@@ -1048,7 +1059,7 @@ class SeparateCompiler
                v.add_abort("type null")
                v.add("\}")
                v.add("if({t}->table_size < 0) \{")
                v.add_abort("type null")
                v.add("\}")
                v.add("if({t}->table_size < 0) \{")

-               v.add("PRINT_ERROR(\"Insantiation of a dead type: %s\\n\", {t}->name);")
+               v.add("PRINT_ERROR(\"Instantiation of a dead type: %s\\n\", {t}->name);")

                v.add_abort("type dead")
                v.add("\}")
        end
                v.add_abort("type dead")
                v.add("\}")
        end

@@ -1169,8 +1180,9 @@ class SeparateCompilerVisitor
                        args.first = self.autobox(args.first, m.mclassdef.mclass.mclass_type)
                end
                for i in [0..msignature.arity[ do
                        args.first = self.autobox(args.first, m.mclassdef.mclass.mclass_type)
                end
                for i in [0..msignature.arity[ do

-                       var t = msignature.mparameters[i].mtype
-                       if i == msignature.vararg_rank then
+                       var mp = msignature.mparameters[i]
+                       var t = mp.mtype
+                       if mp.is_vararg then

                                t = args[i+1].mtype
                        end
                        args[i+1] = self.autobox(args[i+1], t)
                                t = args[i+1].mtype
                        end
                        args[i+1] = self.autobox(args[i+1], t)

@@ -1184,8 +1196,9 @@ class SeparateCompilerVisitor
                        args.first = self.unbox_extern(args.first, m.mclassdef.mclass.mclass_type)
                end
                for i in [0..msignature.arity[ do
                        args.first = self.unbox_extern(args.first, m.mclassdef.mclass.mclass_type)
                end
                for i in [0..msignature.arity[ do

-                       var t = msignature.mparameters[i].mtype
-                       if i == msignature.vararg_rank then
+                       var mp = msignature.mparameters[i]
+                       var t = mp.mtype
+                       if mp.is_vararg then

                                t = args[i+1].mtype
                        end
                        if m.is_extern then args[i+1] = self.unbox_extern(args[i+1], t)
                                t = args[i+1].mtype
                        end
                        if m.is_extern then args[i+1] = self.unbox_extern(args[i+1], t)

@@ -1229,7 +1242,7 @@ class SeparateCompilerVisitor
                                return res
                        end
                        var valtype = value.mtype.as(MClassType)
                                return res
                        end
                        var valtype = value.mtype.as(MClassType)

-                       if mtype isa MClassType and mtype.mclass.kind == extern_kind and mtype.mclass.name != "NativeString" then
+                       if mtype isa MClassType and mtype.mclass.kind == extern_kind and mtype.mclass.name != "CString" then

                                valtype = compiler.mainmodule.pointer_type
                        end
                        var res = self.new_var(mtype)
                                valtype = compiler.mainmodule.pointer_type
                        end
                        var res = self.new_var(mtype)

@@ -1254,7 +1267,7 @@ class SeparateCompilerVisitor
        redef fun unbox_extern(value, mtype)
        do
                if mtype isa MClassType and mtype.mclass.kind == extern_kind and
        redef fun unbox_extern(value, mtype)
        do
                if mtype isa MClassType and mtype.mclass.kind == extern_kind and

-                  mtype.mclass.name != "NativeString" then
+                  mtype.mclass.name != "CString" then

                        var pointer_type = compiler.mainmodule.pointer_type
                        var res = self.new_var_extern(mtype)
                        self.add "{res} = ((struct instance_{pointer_type.c_name}*){value})->value; /* unboxing {value.mtype} */"
                        var pointer_type = compiler.mainmodule.pointer_type
                        var res = self.new_var_extern(mtype)
                        self.add "{res} = ((struct instance_{pointer_type.c_name}*){value})->value; /* unboxing {value.mtype} */"

@@ -1267,7 +1280,7 @@ class SeparateCompilerVisitor
        redef fun box_extern(value, mtype)
        do
                if mtype isa MClassType and mtype.mclass.kind == extern_kind and
        redef fun box_extern(value, mtype)
        do
                if mtype isa MClassType and mtype.mclass.kind == extern_kind and

-                  mtype.mclass.name != "NativeString" then
+                  mtype.mclass.name != "CString" then

                        var valtype = compiler.mainmodule.pointer_type
                        var res = self.new_var(mtype)
                        compiler.undead_types.add(mtype)
                        var valtype = compiler.mainmodule.pointer_type
                        var res = self.new_var(mtype)
                        compiler.undead_types.add(mtype)

@@ -1392,8 +1405,7 @@ class SeparateCompilerVisitor
                var res: nullable RuntimeVariable = null
                var recv = arguments.first
                var consider_null = not self.compiler.modelbuilder.toolcontext.opt_no_check_null.value or mmethod.name == "==" or mmethod.name == "!="
                var res: nullable RuntimeVariable = null
                var recv = arguments.first
                var consider_null = not self.compiler.modelbuilder.toolcontext.opt_no_check_null.value or mmethod.name == "==" or mmethod.name == "!="

-               var maybenull = (recv.mcasttype isa MNullableType or recv.mcasttype isa MNullType) and consider_null
-               if maybenull then
+               if maybe_null(recv) and consider_null then

                        self.add("if ({recv} == NULL) \{")
                        if mmethod.name == "==" or mmethod.name == "is_same_instance" then
                                res = self.new_var(bool_type)
                        self.add("if ({recv} == NULL) \{")
                        if mmethod.name == "==" or mmethod.name == "is_same_instance" then
                                res = self.new_var(bool_type)

@@ -1876,7 +1888,7 @@ class SeparateCompilerVisitor
                if not value.mtype.is_c_primitive then
                        self.add "{res} = {value} == NULL ? \"null\" : {type_info(value)}->name;"
                else if value.mtype isa MClassType and value.mtype.as(MClassType).mclass.kind == extern_kind and
                if not value.mtype.is_c_primitive then
                        self.add "{res} = {value} == NULL ? \"null\" : {type_info(value)}->name;"
                else if value.mtype isa MClassType and value.mtype.as(MClassType).mclass.kind == extern_kind and

-                       value.mtype.as(MClassType).name != "NativeString" then
+                       value.mtype.as(MClassType).name != "CString" then

                        self.add "{res} = \"{value.mtype.as(MClassType).mclass}\";"
                else
                        self.require_declaration("type_{value.mtype.c_name}")
                        self.add "{res} = \"{value.mtype.as(MClassType).mclass}\";"
                else
                        self.require_declaration("type_{value.mtype.c_name}")

@@ -1894,20 +1906,58 @@ class SeparateCompilerVisitor
                        value2 = tmp
                end
                if value1.mtype.is_c_primitive then
                        value2 = tmp
                end
                if value1.mtype.is_c_primitive then

-                       if value2.mtype == value1.mtype then
+                       var t1 = value1.mtype
+                       assert t1 == value1.mcasttype
+
+                       # Fast case: same C type.
+                       if value2.mtype == t1 then
+                               # Same exact C primitive representation.

                                self.add("{res} = {value1} == {value2};")
                                self.add("{res} = {value1} == {value2};")

-                       else if value2.mtype.is_c_primitive then
-                               self.add("{res} = 0; /* incompatible types {value1.mtype} vs. {value2.mtype}*/")
-                       else if value1.mtype.is_tagged then
-                               self.add("{res} = ({value2} != NULL) && ({self.autobox(value2, value1.mtype)} == {value1});")
+                               return res
+                       end
+
+                       # Complex case: value2 has a different representation
+                       # Thus, it should be checked if `value2` is type-compatible with `value1`
+                       # This compatibility is done statically if possible and dynamically else
+
+                       # Conjunction (ands) of dynamic tests according to the static knowledge
+                       var tests = new Array[String]
+
+                       var t2 = value2.mcasttype
+                       if t2 isa MNullableType then
+                               # The destination type cannot be null
+                               tests.add("({value2} != NULL)")
+                               t2 = t2.mtype
+                       else if t2 isa MNullType then
+                               # `value2` is known to be null, thus incompatible with a primitive
+                               self.add("{res} = 0; /* incompatible types {t1} vs. {t2}*/")
+                               return res
+                       end
+
+                       if t2 == t1 then
+                               # Same type but different representation.
+                       else if t2.is_c_primitive then
+                               # Type of `value2` is a different primitive type, thus incompatible
+                               self.add("{res} = 0; /* incompatible types {t1} vs. {t2}*/")
+                               return res
+                       else if t1.is_tagged then
+                               # To be equal, `value2` should also be correctly tagged
+                               tests.add("({extract_tag(value2)} == {t1.tag_value})")

                        else
                        else

-                               var mtype1 = value1.mtype.as(MClassType)
-                               self.require_declaration("class_{mtype1.c_name}")
-                               self.add("{res} = ({value2} != NULL) && ({value2}->class == &class_{mtype1.c_name});")
-                               self.add("if ({res}) \{")
-                               self.add("{res} = ({self.autobox(value2, value1.mtype)} == {value1});")
-                               self.add("\}")
+                               # To be equal, `value2` should also be boxed with the same class
+                               self.require_declaration("class_{t1.c_name}")
+                               tests.add "({class_info(value2)} == &class_{t1.c_name})"

                        end
                        end

+
+                       # Compare the unboxed `value2` with `value1`
+                       if tests.not_empty then
+                               self.add "if ({tests.join(" && ")}) \{"
+                       end
+                       self.add "{res} = {self.autobox(value2, t1)} == {value1};"
+                       if tests.not_empty then
+                               self.add "\} else {res} = 0;"
+                       end
+

                        return res
                end
                var maybe_null = true
                        return res
                end
                var maybe_null = true

@@ -2011,12 +2061,6 @@ class SeparateCompilerVisitor
                return k == interface_kind or t.is_c_primitive
        end
 
                return k == interface_kind or t.is_c_primitive
        end
 

-       fun maybe_null(value: RuntimeVariable): Bool
-       do
-               var t = value.mcasttype
-               return t isa MNullableType or t isa MNullType
-       end
-

        redef fun array_instance(array, elttype)
        do
                var nclass = mmodule.native_array_class
        redef fun array_instance(array, elttype)
        do
                var nclass = mmodule.native_array_class

@@ -2035,7 +2079,7 @@ class SeparateCompilerVisitor
                return res
        end
 
                return res
        end
 

-       redef fun native_array_instance(elttype: MType, length: RuntimeVariable): RuntimeVariable
+       redef fun native_array_instance(elttype, length)

        do
                var mtype = mmodule.native_array_type(elttype)
                self.require_declaration("NEW_{mtype.mclass.c_name}")
        do
                var mtype = mmodule.native_array_type(elttype)
                self.require_declaration("NEW_{mtype.mclass.c_name}")

@@ -2048,11 +2092,11 @@ class SeparateCompilerVisitor
                        var recv = self.frame.arguments.first
                        var recv_type_info = self.type_info(recv)
                        self.require_declaration(mtype.const_color)
                        var recv = self.frame.arguments.first
                        var recv_type_info = self.type_info(recv)
                        self.require_declaration(mtype.const_color)

-                       return self.new_expr("NEW_{mtype.mclass.c_name}({length}, {recv_type_info}->resolution_table->types[{mtype.const_color}])", mtype)
+                       return self.new_expr("NEW_{mtype.mclass.c_name}((int){length}, {recv_type_info}->resolution_table->types[{mtype.const_color}])", mtype)

                end
                compiler.undead_types.add(mtype)
                self.require_declaration("type_{mtype.c_name}")
                end
                compiler.undead_types.add(mtype)
                self.require_declaration("type_{mtype.c_name}")

-               return self.new_expr("NEW_{mtype.mclass.c_name}({length}, &type_{mtype.c_name})", mtype)
+               return self.new_expr("NEW_{mtype.mclass.c_name}((int){length}, &type_{mtype.c_name})", mtype)

        end
 
        redef fun native_array_def(pname, ret_type, arguments)
        end
 
        redef fun native_array_def(pname, ret_type, arguments)

@@ -2065,18 +2109,24 @@ class SeparateCompilerVisitor
                        var res = self.new_expr("{recv}[{arguments[1]}]", compiler.mainmodule.object_type)
                        res.mcasttype = ret_type.as(not null)
                        self.ret(res)
                        var res = self.new_expr("{recv}[{arguments[1]}]", compiler.mainmodule.object_type)
                        res.mcasttype = ret_type.as(not null)
                        self.ret(res)

-                       return
+                       return true

                else if pname == "[]=" then
                        self.add("{recv}[{arguments[1]}]={arguments[2]};")
                else if pname == "[]=" then
                        self.add("{recv}[{arguments[1]}]={arguments[2]};")

-                       return
+                       return true

                else if pname == "length" then
                        self.ret(self.new_expr("((struct instance_{nclass.c_name}*){arguments[0]})->length", ret_type.as(not null)))
                else if pname == "length" then
                        self.ret(self.new_expr("((struct instance_{nclass.c_name}*){arguments[0]})->length", ret_type.as(not null)))

-                       return
+                       return true

                else if pname == "copy_to" then
                        var recv1 = "((struct instance_{nclass.c_name}*){arguments[1]})->values"
                        self.add("memmove({recv1}, {recv}, {arguments[2]}*sizeof({elttype.ctype}));")
                else if pname == "copy_to" then
                        var recv1 = "((struct instance_{nclass.c_name}*){arguments[1]})->values"
                        self.add("memmove({recv1}, {recv}, {arguments[2]}*sizeof({elttype.ctype}));")

-                       return
+                       return true
+               else if pname == "memmove" then
+                       # fun memmove(start: Int, length: Int, dest: NativeArray[E], dest_start: Int) is intern do
+                       var recv1 = "((struct instance_{nclass.c_name}*){arguments[3]})->values"
+                       self.add("memmove({recv1}+{arguments[4]}, {recv}+{arguments[1]}, {arguments[2]}*sizeof({elttype.ctype}));")
+                       return true

                end
                end

+               return false

        end
 
        redef fun native_array_get(nat, i)
        end
 
        redef fun native_array_get(nat, i)

@@ -2203,8 +2253,9 @@ class SeparateRuntimeFunction
                var sig = new FlatBuffer
                sig.append("({called_recv.ctype} self")
                for i in [0..called_signature.arity[ do
                var sig = new FlatBuffer
                sig.append("({called_recv.ctype} self")
                for i in [0..called_signature.arity[ do

-                       var mtype = called_signature.mparameters[i].mtype
-                       if i == called_signature.vararg_rank then
+                       var mp = called_signature.mparameters[i]
+                       var mtype = mp.mtype
+                       if mp.is_vararg then

                                mtype = mmethoddef.mclassdef.mmodule.array_type(mtype)
                        end
                        sig.append(", {mtype.ctype} p{i}")
                                mtype = mmethoddef.mclassdef.mmodule.array_type(mtype)
                        end
                        sig.append(", {mtype.ctype} p{i}")

@@ -2239,8 +2290,9 @@ class SeparateRuntimeFunction
                comment.append("({selfvar}: {selfvar.mtype}")
                arguments.add(selfvar)
                for i in [0..msignature.arity[ do
                comment.append("({selfvar}: {selfvar.mtype}")
                arguments.add(selfvar)
                for i in [0..msignature.arity[ do

-                       var mtype = msignature.mparameters[i].mtype
-                       if i == msignature.vararg_rank then
+                       var mp = msignature.mparameters[i]
+                       var mtype = mp.mtype
+                       if mp.is_vararg then

                                mtype = v.mmodule.array_type(mtype)
                        end
                        comment.append(", {mtype}")
                                mtype = v.mmodule.array_type(mtype)
                        end
                        comment.append(", {mtype}")