X-Git-Url: http://nitlanguage.org diff --git a/src/abstract_compiler.nit b/src/abstract_compiler.nit index 031be97..9d441cc 100644 --- a/src/abstract_compiler.nit +++ b/src/abstract_compiler.nit @@ -27,6 +27,8 @@ import c_tools redef class ToolContext # --output var opt_output: OptionString = new OptionString("Output file", "-o", "--output") + # --dir + var opt_dir: OptionString = new OptionString("Output directory", "--dir") # --no-cc var opt_no_cc: OptionBool = new OptionBool("Do not invoke C compiler", "--no-cc") # --no-main @@ -49,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 @@ -67,8 +71,8 @@ redef class ToolContext redef init do super - self.option_context.add_option(self.opt_output, 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_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_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) @@ -80,15 +84,28 @@ redef class ToolContext super var st = opt_stacktrace.value - if st == null or st == "none" or st == "libunwind" or st == "nitstack" then + if st == "none" or st == "libunwind" or st == "nitstack" then # Fine, do nothing - else if st == "auto" then - # Default just unset - opt_stacktrace.value = null + else if st == "auto" or st == null then + # Default is nitstack + opt_stacktrace.value = "nitstack" else print "Error: unknown value `{st}` for --stacktrace. Use `none`, `libunwind`, `nitstack` or `auto`." exit(1) end + + if opt_output.value != null and opt_dir.value != null then + 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 @@ -200,9 +217,8 @@ class MakefileToolchain fun write_files(compiler: AbstractCompiler, compile_dir: String, cfiles: Array[String]) do - if self.toolcontext.opt_stacktrace.value == "nitstack" then compiler.build_c_to_nit_bindings - var platform = compiler.mainmodule.target_platform + if self.toolcontext.opt_stacktrace.value == "nitstack" and (platform == null or platform.supports_libunwind) then compiler.build_c_to_nit_bindings var cc_opt_with_libgc = "-DWITH_LIBGC" if platform != null and not platform.supports_libgc then cc_opt_with_libgc = "" @@ -296,11 +312,23 @@ class MakefileToolchain fun default_outname(mainmodule: MModule): String do return mainmodule.name + # Combine options and platform informations to get the final path of the outfile + fun outfile(mainmodule: MModule): String + do + var res = self.toolcontext.opt_output.value + if res != null then return res + res = default_outname(mainmodule) + var dir = self.toolcontext.opt_dir.value + if dir != null then return dir.join_path(res) + return res + end + fun write_makefile(compiler: AbstractCompiler, compile_dir: String, cfiles: Array[String]) do var mainmodule = compiler.mainmodule + var platform = compiler.mainmodule.target_platform - var outname = self.toolcontext.opt_output.value or else default_outname(mainmodule) + var outname = outfile(mainmodule) var orig_dir=".." # FIXME only works if `compile_dir` is a subdirectory of cwd var outpath = orig_dir.join_path(outname).simplify_path @@ -320,10 +348,28 @@ class MakefileToolchain if libs != null then linker_options.add_all(libs) end + makefile.write("CC = ccache cc\nCXX = ccache c++\nCFLAGS = -g -O2 -Wno-unused-value -Wno-switch\nCINCL = {cc_includes}\nLDFLAGS ?= \nLDLIBS ?= -lm -lgc {linker_options.join(" ")}\n\n") + var ost = toolcontext.opt_stacktrace.value - if ost == "libunwind" or ost == "nitstack" then linker_options.add("-lunwind") + if (ost == "libunwind" or ost == "nitstack") and (platform == null or platform.supports_libunwind) then makefile.write("NEED_LIBUNWIND := YesPlease\n") + + # Dynamic adaptations + # While `platform` enable complex toolchains, they are statically applied + # For a dynamic adaptsation of the compilation, the generated Makefile should check and adapt things itself + + # Check and adapt the targeted system + makefile.write("uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')\n") + makefile.write("ifeq ($(uname_S),Darwin)\n") + # remove -lunwind since it is already included on macosx + makefile.write("\tNEED_LIBUNWIND :=\n") + makefile.write("endif\n\n") + + # Check and adapt for the compiler used + # clang need an additionnal `-Qunused-arguments` + makefile.write("clang_check := $(shell sh -c '$(CC) -v 2>&1 | grep -q clang; echo $$?')\nifeq ($(clang_check), 0)\n\tCFLAGS += -Qunused-arguments\nendif\n") + + makefile.write("ifdef NEED_LIBUNWIND\n\tLDLIBS += -lunwind\nendif\n") - makefile.write("CC = ccache cc\nCFLAGS = -g -O2 -Wno-unused-value -Wno-switch\nCINCL = {cc_includes}\nLDFLAGS ?= \nLDLIBS ?= -lm -lgc {linker_options.join(" ")}\n\n") makefile.write("all: {outpath}\n\n") var ofiles = new Array[String] @@ -542,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: @@ -556,16 +654,9 @@ abstract class AbstractCompiler var ost = modelbuilder.toolcontext.opt_stacktrace.value var platform = mainmodule.target_platform - if ost == null then - if platform != null and not platform.supports_libunwind then - ost = "none" - else - ost = "nitstack" - end - modelbuilder.toolcontext.opt_stacktrace.value = ost - end + if platform != null and not platform.supports_libunwind then ost = "none" - if platform != null and platform.no_main then modelbuilder.toolcontext.opt_no_main.value = true + var no_main = (platform != null and platform.no_main) or modelbuilder.toolcontext.opt_no_main.value if ost == "nitstack" or ost == "libunwind" then v.add_decl("#define UNW_LOCAL_ONLY") @@ -643,7 +734,7 @@ abstract class AbstractCompiler v.add_decl("exit(signo);") v.add_decl("\}") - if modelbuilder.toolcontext.opt_no_main.value then + if no_main then v.add_decl("int nit_main(int argc, char** argv) \{") else v.add_decl("int main(int argc, char** argv) \{") @@ -659,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 @@ -668,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 @@ -718,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] @@ -888,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 @@ -1028,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 @@ -1132,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 @@ -1662,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 @@ -1685,6 +1875,8 @@ redef class AMethPropdef else compile_externmeth_to_c(v, mpropdef, arguments) end + else + abort end end @@ -1881,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))) @@ -1995,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 @@ -2040,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 @@ -2048,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 @@ -2261,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("\}") @@ -2516,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("\}") @@ -2553,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) @@ -2565,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) @@ -2716,6 +2963,7 @@ redef class MModule properties.add_all(self.properties(parent)) end for mclassdef in mclass.mclassdefs do + if not self.in_importation <= mclassdef.mmodule then continue for mprop in mclassdef.intro_mproperties do properties.add(mprop) end @@ -2740,7 +2988,7 @@ var toolcontext = new ToolContext var opt_mixins = new OptionArray("Additionals module to min-in", "-m") toolcontext.option_context.add_option(opt_mixins) -toolcontext.tooldescription = "Usage: nitg [OPTION]... file.nit\nCompiles Nit programs." +toolcontext.tooldescription = "Usage: nitg [OPTION]... file.nit...\nCompiles Nit programs." # We do not add other options, so process them now! toolcontext.process_options(args) @@ -2751,26 +2999,24 @@ var model = new Model var modelbuilder = new ModelBuilder(model, toolcontext) var arguments = toolcontext.option_context.rest -if arguments.length > 1 then - print "Too much arguments: {arguments.join(" ")}" - print toolcontext.tooldescription +if arguments.length > 1 and toolcontext.opt_output.value != null then + print "Error: --output needs a single source file. Do you prefer --dir?" exit 1 end -var progname = arguments.first # Here we load an process all modules passed on the command line -var mmodules = modelbuilder.parse([progname]) -mmodules.add_all modelbuilder.parse(opt_mixins.value) +var mmodules = modelbuilder.parse(arguments) +var mixins = modelbuilder.parse(opt_mixins.value) if mmodules.is_empty then return modelbuilder.run_phases -var mainmodule -if mmodules.length == 1 then - mainmodule = mmodules.first -else - mainmodule = new MModule(model, null, mmodules.first.name, mmodules.first.location) - mainmodule.set_imported_mmodules(mmodules) +for mmodule in mmodules do + toolcontext.info("*** PROCESS {mmodule} ***", 1) + var ms = [mmodule] + if not mixins.is_empty then + ms.add_all mixins + end + toolcontext.run_global_phases(ms) end -toolcontext.run_global_phases(mmodules)