X-Git-Url: http://nitlanguage.org diff --git a/src/abstract_compiler.nit b/src/abstract_compiler.nit index 8a26d1e..9d441cc 100644 --- a/src/abstract_compiler.nit +++ b/src/abstract_compiler.nit @@ -51,8 +51,10 @@ redef class ToolContext var opt_no_check_assert: OptionBool = new OptionBool("Disable the evaluation of explicit 'assert' and 'as' (dangerous)", "--no-check-assert") # --no-check-autocast var opt_no_check_autocast: OptionBool = new OptionBool("Disable implicit casts on unsafe expression usage (dangerous)", "--no-check-autocast") - # --no-check-other - var opt_no_check_other: OptionBool = new OptionBool("Disable implicit tests: unset attribute, null receiver (dangerous)", "--no-check-other") + # --no-check-null + var opt_no_check_null: OptionBool = new OptionBool("Disable tests of null receiver (dangerous)", "--no-check-null") + # --no-check-all + var opt_no_check_all: OptionBool = new OptionBool("Disable all tests (dangerous)", "--no-check-all") # --typing-test-metrics var opt_typing_test_metrics: OptionBool = new OptionBool("Enable static and dynamic count of all type tests", "--typing-test-metrics") # --invocation-metrics @@ -70,7 +72,7 @@ redef class ToolContext do super self.option_context.add_option(self.opt_output, self.opt_dir, self.opt_no_cc, self.opt_no_main, self.opt_make_flags, self.opt_compile_dir, self.opt_hardening, self.opt_no_shortcut_range) - self.option_context.add_option(self.opt_no_check_covariance, self.opt_no_check_attr_isset, self.opt_no_check_assert, self.opt_no_check_autocast, self.opt_no_check_other) + self.option_context.add_option(self.opt_no_check_covariance, self.opt_no_check_attr_isset, self.opt_no_check_assert, self.opt_no_check_autocast, self.opt_no_check_null, self.opt_no_check_all) self.option_context.add_option(self.opt_typing_test_metrics, self.opt_invocation_metrics, self.opt_isset_checks_metrics) self.option_context.add_option(self.opt_stacktrace) self.option_context.add_option(self.opt_no_gcc_directive) @@ -96,6 +98,14 @@ redef class ToolContext print "Error: cannot use both --dir and --output" exit(1) end + + if opt_no_check_all.value then + opt_no_check_covariance.value = true + opt_no_check_attr_isset.value = true + opt_no_check_assert.value = true + opt_no_check_autocast.value = true + opt_no_check_null.value = true + end end end @@ -578,7 +588,59 @@ abstract class AbstractCompiler protected fun compile_header_structs is abstract # Declaration of structures for nitni undelying the FFI - protected fun compile_nitni_structs is abstract + protected fun compile_nitni_structs + do + self.header.add_decl """ +/* Native reference to Nit objects */ +/* This structure is used to represent every Nit type in extern methods and custom C code. */ +struct nitni_ref { + struct nitni_ref *next, + *prev; /* adjacent global references in global list */ + int count; /* number of time this global reference has been marked */ +}; + +/* List of global references from C code to Nit objects */ +/* Instanciated empty at init of Nit system and filled explicitly by user in C code */ +struct nitni_global_ref_list_t { + struct nitni_ref *head, *tail; +}; +extern struct nitni_global_ref_list_t *nitni_global_ref_list; + +/* Initializer of global reference list */ +extern void nitni_global_ref_list_init(); + +/* Intern function to add a global reference to the list */ +extern void nitni_global_ref_add( struct nitni_ref *ref ); + +/* Intern function to remove a global reference from the list */ +extern void nitni_global_ref_remove( struct nitni_ref *ref ); + +/* Increase count on an existing global reference */ +extern void nitni_global_ref_incr( struct nitni_ref *ref ); + +/* Decrease count on an existing global reference */ +extern void nitni_global_ref_decr( struct nitni_ref *ref ); +""" + end + + fun compile_finalizer_function + do + var finalizable_type = mainmodule.finalizable_type + if finalizable_type == null then return + + var finalize_meth = mainmodule.try_get_primitive_method("finalize", finalizable_type.mclass) + + if finalize_meth == null then + modelbuilder.toolcontext.error(null, "The `Finalizable` class doesn't declare the `finalize` method.") + return + end + + var v = self.new_visitor + v.add_decl "void gc_finalize (void *obj, void *client_data) \{" + var recv = v.new_expr("obj", finalizable_type) + v.send(finalize_meth, [recv]) + v.add "\}" + end # Generate the main C function. # This function: @@ -688,6 +750,9 @@ abstract class AbstractCompiler v.add("glob_argc = argc; glob_argv = argv;") v.add("initialize_gc_option();") + + v.add "initialize_nitni_global_refs();" + var main_type = mainmodule.sys_type if main_type != null then var mainmodule = v.compiler.mainmodule @@ -697,7 +762,8 @@ abstract class AbstractCompiler if main_init != null then v.send(main_init, [glob_sys]) end - var main_method = mainmodule.try_get_primitive_method("main", main_type.mclass) + var main_method = mainmodule.try_get_primitive_method("run", main_type.mclass) or else + mainmodule.try_get_primitive_method("main", main_type.mclass) if main_method != null then v.send(main_method, [glob_sys]) end @@ -747,6 +813,67 @@ abstract class AbstractCompiler v.add("\}") end + # Copile all C functions related to the [incr|decr]_ref features of the FFI + fun compile_nitni_global_ref_functions + do + var v = self.new_visitor + v.add """ +struct nitni_global_ref_list_t *nitni_global_ref_list; +void initialize_nitni_global_refs() { + nitni_global_ref_list = (struct nitni_global_ref_list_t*)nit_alloc(sizeof(struct nitni_global_ref_list_t)); + nitni_global_ref_list->head = NULL; + nitni_global_ref_list->tail = NULL; +} + +void nitni_global_ref_add( struct nitni_ref *ref ) { + if ( nitni_global_ref_list->head == NULL ) { + nitni_global_ref_list->head = ref; + ref->prev = NULL; + } else { + nitni_global_ref_list->tail->next = ref; + ref->prev = nitni_global_ref_list->tail; + } + nitni_global_ref_list->tail = ref; + + ref->next = NULL; +} + +void nitni_global_ref_remove( struct nitni_ref *ref ) { + if ( ref->prev == NULL ) { + nitni_global_ref_list->head = ref->next; + } else { + ref->prev->next = ref->next; + } + + if ( ref->next == NULL ) { + nitni_global_ref_list->tail = ref->prev; + } else { + ref->next->prev = ref->prev; + } +} + +extern void nitni_global_ref_incr( struct nitni_ref *ref ) { + if ( ref->count == 0 ) /* not registered */ + { + /* add to list */ + nitni_global_ref_add( ref ); + } + + ref->count ++; +} + +extern void nitni_global_ref_decr( struct nitni_ref *ref ) { + if ( ref->count == 1 ) /* was last reference */ + { + /* remove from list */ + nitni_global_ref_remove( ref ); + } + + ref->count --; +} +""" + end + # List of additional files required to compile (FFI) var extern_bodies = new Array[ExternFile] @@ -917,9 +1044,27 @@ abstract class AbstractCompilerVisitor return self.compiler.modelbuilder.force_get_primitive_method(self.current_node.as(not null), name, recv.mclass, self.compiler.mainmodule) end - fun compile_callsite(callsite: CallSite, args: Array[RuntimeVariable]): nullable RuntimeVariable + fun compile_callsite(callsite: CallSite, arguments: Array[RuntimeVariable]): nullable RuntimeVariable do - return self.send(callsite.mproperty, args) + var initializers = callsite.mpropdef.initializers + if not initializers.is_empty then + var recv = arguments.first + + assert initializers.length == arguments.length - 1 else debug("expected {initializers.length}, got {arguments.length - 1}") + var i = 1 + for p in initializers do + if p isa MMethod then + self.send(p, [recv, arguments[i]]) + else if p isa MAttribute then + self.write_attribute(p, recv, arguments[i]) + else abort + i += 1 + end + + return self.send(callsite.mproperty, [recv]) + end + + return self.send(callsite.mproperty, arguments) end fun native_array_instance(elttype: MType, length: RuntimeVariable): RuntimeVariable is abstract @@ -1057,7 +1202,7 @@ abstract class AbstractCompilerVisitor # Add a check and an abort for a null reciever if needed fun check_recv_notnull(recv: RuntimeVariable) do - if self.compiler.modelbuilder.toolcontext.opt_no_check_other.value then return + if self.compiler.modelbuilder.toolcontext.opt_no_check_null.value then return var maybenull = recv.mcasttype isa MNullableType or recv.mcasttype isa MNullType if maybenull then @@ -1161,6 +1306,17 @@ abstract class AbstractCompilerVisitor # Generate a alloc-instance + init-attributes fun init_instance(mtype: MClassType): RuntimeVariable is abstract + # Set a GC finalizer on `recv`, only if `recv` isa Finalizable + fun set_finalizer(recv: RuntimeVariable) + do + var mtype = recv.mtype + var finalizable_type = compiler.mainmodule.finalizable_type + if finalizable_type != null and not mtype.need_anchor and + mtype.is_subtype(compiler.mainmodule, null, finalizable_type) then + add "gc_register_finalizer({recv});" + end + end + # Generate an integer value fun int_instance(value: Int): RuntimeVariable do @@ -1691,13 +1847,18 @@ redef class AMethPropdef if auto_super_inits != null then var args = [arguments.first] for auto_super_init in auto_super_inits do + assert auto_super_init.mproperty != mpropdef.mproperty args.clear for i in [0..auto_super_init.msignature.arity+1[ do args.add(arguments[i]) end + assert auto_super_init.mproperty != mpropdef.mproperty v.compile_callsite(auto_super_init, args) end end + if auto_super_call then + v.supercall(mpropdef, arguments.first.mtype.as(MClassType), arguments) + end var n_block = n_block if n_block != null then @@ -1714,6 +1875,8 @@ redef class AMethPropdef else compile_externmeth_to_c(v, mpropdef, arguments) end + else + abort end end @@ -1910,7 +2073,7 @@ redef class AMethPropdef v.add("{arguments[0]}[{arguments[1]}]={arguments[2]};") return else if pname == "copy_to" then - v.add("memcpy({arguments[1]}+{arguments[4]},{arguments[0]}+{arguments[3]},{arguments[2]});") + v.add("memmove({arguments[1]}+{arguments[4]},{arguments[0]}+{arguments[3]},{arguments[2]});") return else if pname == "atoi" then v.ret(v.new_expr("atoi({arguments[0]});", ret.as(not null))) @@ -2024,18 +2187,55 @@ end redef class AAttrPropdef redef fun compile_to_c(v, mpropdef, arguments) do - if arguments.length == 1 then - var res = v.read_attribute(self.mpropdef.mproperty, arguments.first) + if mpropdef == mreadpropdef then + assert arguments.length == 1 + var res + if is_lazy then + var nexpr = n_expr + assert nexpr != null + var set + var ret = self.mpropdef.static_mtype + var useiset = ret.ctype == "val*" and not ret isa MNullableType + var guard = self.mlazypropdef.mproperty + if useiset then + set = v.isset_attribute(self.mpropdef.mproperty, arguments.first) + else + set = v.read_attribute(guard, arguments.first) + end + v.add("if(likely({set})) \{") + res = v.read_attribute(self.mpropdef.mproperty, arguments.first) + v.add("\} else \{") + var value = v.expr(nexpr, self.mpropdef.static_mtype) + v.write_attribute(self.mpropdef.mproperty, arguments.first, value) + v.assign(res, value) + if not useiset then + var true_v = v.new_expr("1", v.bool_type) + v.write_attribute(guard, arguments.first, true_v) + end + v.add("\}") + else + res = v.read_attribute(self.mpropdef.mproperty, arguments.first) + end v.assign(v.frame.returnvar.as(not null), res) - else + else if mpropdef == mwritepropdef then + assert arguments.length == 2 v.write_attribute(self.mpropdef.mproperty, arguments.first, arguments[1]) + if is_lazy then + var ret = self.mpropdef.static_mtype + var useiset = ret.ctype == "val*" and not ret isa MNullableType + if not useiset then + v.write_attribute(self.mlazypropdef.mproperty, arguments.first, v.new_expr("1", v.bool_type)) + end + end + else + abort end end fun init_expr(v: AbstractCompilerVisitor, recv: RuntimeVariable) do var nexpr = self.n_expr - if nexpr != null then + if nexpr != null and not is_lazy then var oldnode = v.current_node v.current_node = self var old_frame = v.frame @@ -2069,6 +2269,15 @@ redef class AClassdef private fun compile_to_c(v: AbstractCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable]) do if mpropdef == self.mfree_init then + if mpropdef.mproperty.is_root_init then + assert self.super_inits == null + assert arguments.length == 1 + if not mpropdef.is_intro then + v.supercall(mpropdef, arguments.first.mtype.as(MClassType), arguments) + end + return + end + var super_inits = self.super_inits if super_inits != null then var args_of_super = arguments @@ -2077,11 +2286,12 @@ redef class AClassdef v.send(su, args_of_super) end end + var recv = arguments.first var i = 1 # Collect undefined attributes for npropdef in self.n_propdefs do - if npropdef isa AAttrPropdef and npropdef.n_expr == null then + if npropdef isa AAttrPropdef and npropdef.n_expr == null and not npropdef.noinit then v.write_attribute(npropdef.mpropdef.mproperty, recv, arguments[i]) i += 1 end @@ -2290,22 +2500,28 @@ redef class AForExpr # Shortcut on explicit range # Avoid the instantiation of the range and the iterator var nexpr = self.n_expr - if self.variables.length == 1 and nexpr isa AOrangeExpr and not v.compiler.modelbuilder.toolcontext.opt_no_shortcut_range.value then + if self.variables.length == 1 and nexpr isa ARangeExpr and not v.compiler.modelbuilder.toolcontext.opt_no_shortcut_range.value then var from = v.expr(nexpr.n_expr, null) var to = v.expr(nexpr.n_expr2, null) var variable = v.variable(variables.first) + var one = v.new_expr("1", v.get_class("Int").mclass_type) v.assign(variable, from) v.add("for(;;) \{ /* shortcut range */") - var ok = v.send(v.get_property("<", variable.mtype), [variable, to]) + var ok + if nexpr isa AOrangeExpr then + ok = v.send(v.get_property("<", variable.mtype), [variable, to]) + else + ok = v.send(v.get_property("<=", variable.mtype), [variable, to]) + end assert ok != null v.add("if(!{ok}) break;") v.stmt(self.n_block) v.add("CONTINUE_{v.escapemark_name(escapemark)}: (void)0;") - var succ = v.send(v.get_property("succ", variable.mtype), [variable]) + var succ = v.send(v.get_property("successor", variable.mtype), [variable, one]) assert succ != null v.assign(variable, succ) v.add("\}") @@ -2545,6 +2761,8 @@ redef class AAsNotnullExpr var i = v.expr(self.n_expr, null) if v.compiler.modelbuilder.toolcontext.opt_no_check_assert.value then return i + if i.mtype.ctype != "val*" then return i + v.add("if (unlikely({i} == NULL)) \{") v.add_abort("Cast failed") v.add("\}") @@ -2582,7 +2800,7 @@ redef class ASendExpr do var recv = v.expr(self.n_expr, null) var args = [recv] - for a in self.raw_arguments.as(not null) do + for a in self.raw_arguments do args.add(v.expr(a, null)) end return v.compile_callsite(self.callsite.as(not null), args) @@ -2594,7 +2812,7 @@ redef class ASendReassignFormExpr do var recv = v.expr(self.n_expr, null) var args = [recv] - for a in self.raw_arguments.as(not null) do + for a in self.raw_arguments do args.add(v.expr(a, null)) end var value = v.expr(self.n_value, null)