X-Git-Url: http://nitlanguage.org diff --git a/src/global_compiler.nit b/src/global_compiler.nit index d9eff2f..e09d040 100644 --- a/src/global_compiler.nit +++ b/src/global_compiler.nit @@ -41,6 +41,9 @@ redef class ToolContext # --hardening var opt_hardening: OptionBool = new OptionBool("Generate contracts in the C code against bugs in the compiler", "--hardening") + # --no-shortcut-range + var opt_no_shortcut_range: OptionBool = new OptionBool("Always insantiate a range and its iterator on 'for' loops", "--no-shortcut-range") + # --no-check-covariance var opt_no_check_covariance: OptionBool = new OptionBool("Disable type tests of covariant parameters (dangerous)", "--no-check-covariance") @@ -56,11 +59,15 @@ redef class ToolContext # --no-check-other var opt_no_check_other: OptionBool = new OptionBool("Disable implicit tests: unset attribute, null receiver (dangerous)", "--no-check-other") + # --typing-test-metrics + var opt_typing_test_metrics: OptionBool = new OptionBool("Enable static and dynamic count of all type tests", "--typing-test-metrics") + redef init do super - self.option_context.add_option(self.opt_output, self.opt_no_cc, self.opt_make_flags, self.opt_hardening) + self.option_context.add_option(self.opt_output, self.opt_no_cc, self.opt_make_flags, self.opt_hardening, self.opt_no_shortcut_range) self.option_context.add_option(self.opt_no_check_covariance, self.opt_no_check_initialization, self.opt_no_check_assert, self.opt_no_check_autocast, self.opt_no_check_other) + self.option_context.add_option(self.opt_typing_test_metrics) end end @@ -74,6 +81,7 @@ redef class ModelBuilder self.toolcontext.info("*** COMPILING TO C ***", 1) var compiler = new GlobalCompiler(mainmodule, runtime_type_analysis, self) + compiler.compile_header var v = compiler.header for t in runtime_type_analysis.live_types do @@ -103,6 +111,8 @@ redef class ModelBuilder end self.toolcontext.info("Total methods to compile to C: {compiler.visitors.length}", 2) + compiler.display_stats + var time1 = get_time self.toolcontext.info("*** END VISITING: {time1-time0} ***", 2) write_and_make(compiler) @@ -139,7 +149,7 @@ redef class ModelBuilder var i = 0 for vis in compiler.visitors do count += vis.lines.length - if file == null or count > 10000 then + if file == null or count > 10000 or vis.file_break then i += 1 if file != null then file.close var cfilename = ".nit_compile/{mainmodule.name}.{i}.c" @@ -246,20 +256,30 @@ class GlobalCompiler self.live_primitive_types.add(t) end end + end - # Header declarations - self.compile_header + # Force the creation of a new file + # The point is to avoid contamination between must-be-compiled-separately files + fun new_file + do + var v = self.new_visitor + v.file_break = true end - protected fun compile_header do + fun compile_header do var v = self.header self.header.add_decl("#include ") self.header.add_decl("#include ") self.header.add_decl("#include ") self.header.add_decl("#ifndef NOBOEHM") self.header.add_decl("#include ") + self.header.add_decl("#ifdef NOBOEHM_ATOMIC") + self.header.add_decl("#undef GC_MALLOC_ATOMIC") + self.header.add_decl("#define GC_MALLOC_ATOMIC(x) GC_MALLOC(x)") + self.header.add_decl("#endif /*NOBOEHM_ATOMIC*/") self.header.add_decl("#else /*NOBOEHM*/") self.header.add_decl("#define GC_MALLOC(x) calloc(1, (x))") + self.header.add_decl("#define GC_MALLOC_ATOMIC(x) calloc(1, (x))") self.header.add_decl("#endif /*NOBOEHM*/") compile_header_structs @@ -488,6 +508,20 @@ class GlobalCompiler # Initialize a visitor specific for a compiler engine fun new_visitor: GlobalCompilerVisitor do return new GlobalCompilerVisitor(self) + var count_type_test_tags: Array[String] = ["isa", "as", "auto", "covariance", "erasure"] + var count_type_test_resolved: HashMap[String, Int] = init_count_type_test_tags + var count_type_test_unresolved: HashMap[String, Int] = init_count_type_test_tags + var count_type_test_skipped: HashMap[String, Int] = init_count_type_test_tags + + private fun init_count_type_test_tags: HashMap[String, Int] + do + var res = new HashMap[String, Int] + for tag in count_type_test_tags do + res[tag] = 0 + end + return res + end + # Generate the main C function. # This function: # allocate the Sys object if it exists @@ -499,6 +533,17 @@ class GlobalCompiler v.add_decl("int glob_argc;") v.add_decl("char **glob_argv;") v.add_decl("val *glob_sys;") + + if self.modelbuilder.toolcontext.opt_typing_test_metrics.value then + for tag in count_type_test_tags do + v.add_decl("long count_type_test_resolved_{tag};") + v.add_decl("long count_type_test_unresolved_{tag};") + v.add_decl("long count_type_test_skipped_{tag};") + v.compiler.header.add_decl("extern long count_type_test_resolved_{tag};") + v.compiler.header.add_decl("extern long count_type_test_unresolved_{tag};") + v.compiler.header.add_decl("extern long count_type_test_skipped_{tag};") + end + end v.add_decl("int main(int argc, char** argv) \{") v.add("glob_argc = argc; glob_argv = argv;") var main_type = mainmodule.sys_type @@ -515,11 +560,74 @@ class GlobalCompiler v.send(main_method, [glob_sys]) end end + + if self.modelbuilder.toolcontext.opt_typing_test_metrics.value then + v.add_decl("long count_type_test_resolved_total = 0;") + v.add_decl("long count_type_test_unresolved_total = 0;") + v.add_decl("long count_type_test_skipped_total = 0;") + v.add_decl("long count_type_test_total_total = 0;") + for tag in count_type_test_tags do + v.add_decl("long count_type_test_total_{tag};") + v.add("count_type_test_total_{tag} = count_type_test_resolved_{tag} + count_type_test_unresolved_{tag} + count_type_test_skipped_{tag};") + v.add("count_type_test_resolved_total += count_type_test_resolved_{tag};") + v.add("count_type_test_unresolved_total += count_type_test_unresolved_{tag};") + v.add("count_type_test_skipped_total += count_type_test_skipped_{tag};") + v.add("count_type_test_total_total += count_type_test_total_{tag};") + end + v.add("printf(\"# dynamic count_type_test: total %l\\n\");") + v.add("printf(\"\\tresolved\\tunresolved\\tskipped\\ttotal\\n\");") + var tags = count_type_test_tags.to_a + tags.add("total") + for tag in tags do + v.add("printf(\"{tag}\");") + v.add("printf(\"\\t%ld (%.2f%%)\", count_type_test_resolved_{tag}, 100.0*count_type_test_resolved_{tag}/count_type_test_total_total);") + v.add("printf(\"\\t%ld (%.2f%%)\", count_type_test_unresolved_{tag}, 100.0*count_type_test_unresolved_{tag}/count_type_test_total_total);") + v.add("printf(\"\\t%ld (%.2f%%)\", count_type_test_skipped_{tag}, 100.0*count_type_test_skipped_{tag}/count_type_test_total_total);") + v.add("printf(\"\\t%ld (%.2f%%)\\n\", count_type_test_total_{tag}, 100.0*count_type_test_total_{tag}/count_type_test_total_total);") + end + end v.add("return 0;") v.add("\}") end + fun div(a,b:Int):String + do + if b == 0 then return "n/a" + return ((a*10000/b).to_f / 100.0).to_precision(2) + end + + fun display_stats + do + if self.modelbuilder.toolcontext.opt_typing_test_metrics.value then + print "# static count_type_test" + print "\tresolved:\tunresolved\tskipped\ttotal" + var count_type_test_total = init_count_type_test_tags + count_type_test_resolved["total"] = 0 + count_type_test_unresolved["total"] = 0 + count_type_test_skipped["total"] = 0 + count_type_test_total["total"] = 0 + for tag in count_type_test_tags do + count_type_test_total[tag] = count_type_test_resolved[tag] + count_type_test_unresolved[tag] + count_type_test_skipped[tag] + count_type_test_resolved["total"] += count_type_test_resolved[tag] + count_type_test_unresolved["total"] += count_type_test_unresolved[tag] + count_type_test_skipped["total"] += count_type_test_skipped[tag] + count_type_test_total["total"] += count_type_test_total[tag] + end + var count_type_test = count_type_test_total["total"] + var tags = count_type_test_tags.to_a + tags.add("total") + for tag in tags do + printn tag + printn "\t{count_type_test_resolved[tag]} ({div(count_type_test_resolved[tag],count_type_test)}%)" + printn "\t{count_type_test_unresolved[tag]} ({div(count_type_test_unresolved[tag],count_type_test)}%)" + printn "\t{count_type_test_skipped[tag]} ({div(count_type_test_skipped[tag],count_type_test)}%)" + printn "\t{count_type_test_total[tag]} ({div(count_type_test_total[tag],count_type_test)}%)" + print "" + end + end + end + private var collect_types_cache: HashMap[MType, Array[MClassType]] = new HashMap[MType, Array[MClassType]] end @@ -587,6 +695,11 @@ redef class MType return "val*" end + fun ctypename: String + do + return "val" + end + # Return the name of the C structure associated to a Nit live type # FIXME: move to GlobalCompiler so we can check that self is a live type fun c_name: String is abstract @@ -624,6 +737,28 @@ redef class MClassType return "val*" end end + + redef fun ctypename: String + do + if mclass.name == "Int" then + return "l" + else if mclass.name == "Bool" then + return "s" + else if mclass.name == "Char" then + return "c" + else if mclass.name == "Float" then + return "d" + else if mclass.name == "NativeString" then + return "str" + else if mclass.name == "NativeArray" then + #return "{self.arguments.first.ctype}*" + return "val" + else if mclass.kind == extern_kind then + return "ptr" + else + return "val" + end + end end redef class MGenericType @@ -889,6 +1024,8 @@ class GlobalCompilerVisitor compiler.visitors.add(self) end + var file_break: Bool = false + # Alias for self.compiler.mainmodule.object_type fun object_type: MClassType do return self.compiler.mainmodule.object_type @@ -948,12 +1085,14 @@ class GlobalCompilerVisitor mtype = self.anchor(mtype) res = self.autobox(res, mtype) end + res = autoadapt(res, nexpr.mtype.as(not null)) var implicit_cast_to = nexpr.implicit_cast_to if implicit_cast_to != null and not self.compiler.modelbuilder.toolcontext.opt_no_check_autocast.value then - var castres = self.type_test(res, implicit_cast_to) + var castres = self.type_test(res, implicit_cast_to, "auto") self.add("if (!{castres}) \{") self.add_abort("Cast failed") self.add("\}") + res = autoadapt(res, implicit_cast_to) end self.current_node = old return res @@ -1232,13 +1371,7 @@ class GlobalCompilerVisitor self.add("/* skip, no method {m} */") return res end - var propdefs = m.lookup_definitions(self.compiler.mainmodule, mclasstype) - if propdefs.length == 0 then - self.add("/* skip, no method {m} */") - return res - end - assert propdefs.length == 1 - var propdef = propdefs.first + var propdef = m.lookup_first_definition(self.compiler.mainmodule, mclasstype) var res2 = self.call(propdef, mclasstype, args) if res != null then self.assign(res, res2.as(not null)) return res @@ -1282,15 +1415,7 @@ class GlobalCompilerVisitor var last = types.last var defaultpropdef: nullable MMethodDef = null for t in types do - var propdefs = m.lookup_definitions(self.compiler.mainmodule, t) - if propdefs.length == 0 then - self.add("/* skip {t}, no method {m} */") - continue - end - if propdefs.length > 1 then - self.debug("NOT YET IMPLEMENTED conflict for {t}.{m}: {propdefs.join(" ")}. choose the first") - end - var propdef = propdefs.first + var propdef = m.lookup_first_definition(self.compiler.mainmodule, t) if propdef.mclassdef.mclass.name == "Object" and t.ctype == "val*" then defaultpropdef = propdef continue @@ -1320,14 +1445,7 @@ class GlobalCompilerVisitor fun monomorphic_send(m: MMethod, t: MType, args: Array[RuntimeVariable]): nullable RuntimeVariable do assert t isa MClassType - var propdefs = m.lookup_definitions(self.compiler.mainmodule, t) - if propdefs.length == 0 then - abort - end - if propdefs.length > 1 then - self.debug("NOT YET IMPLEMENTED conflict for {t}.{m}: {propdefs.join(" ")}. choose the first") - end - var propdef = propdefs.first + var propdef = m.lookup_first_definition(self.compiler.mainmodule, t) return self.call(propdef, t, args) end @@ -1569,7 +1687,7 @@ class GlobalCompilerVisitor end # Generate a polymorphic subtype test - fun type_test(value: RuntimeVariable, mtype: MType): RuntimeVariable + fun type_test(value: RuntimeVariable, mtype: MType, tag: String): RuntimeVariable do mtype = self.anchor(mtype) var mclasstype = mtype @@ -1863,7 +1981,7 @@ redef class MMethodDef # generate the cast # note that v decides if and how to implements the cast v.add("/* Covariant cast for argument {i} ({self.msignature.mparameters[i].name}) {arguments[i+1].inspect} isa {mtype} */") - var cond = v.type_test( arguments[i+1], mtype) + var cond = v.type_test(arguments[i+1], mtype, "covariance") v.add("if (!{cond}) \{") #var x = v.class_name_string(arguments[i+1]) #var y = v.class_name_string(arguments.first) @@ -2146,7 +2264,7 @@ redef class AInternMethPropdef v.ret(v.new_expr("glob_sys", ret.as(not null))) return else if pname == "calloc_string" then - v.ret(v.new_expr("(char*)GC_MALLOC({arguments[1]})", ret.as(not null))) + v.ret(v.new_expr("(char*)GC_MALLOC_ATOMIC({arguments[1]})", ret.as(not null))) return else if pname == "calloc_array" then v.calloc_array(ret.as(not null), arguments) @@ -2493,6 +2611,32 @@ end redef class AForExpr redef fun stmt(v) do + # 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 + var from = v.expr(nexpr.n_expr, null) + var to = v.expr(nexpr.n_expr2, null) + var variable = v.variable(variables.first) + + v.assign(variable, from) + v.add("for(;;) \{ /* shortcut range */") + + var ok = v.send(v.get_property("<", variable.mtype), [variable, to]) + 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]) + assert succ != null + v.assign(variable, succ) + v.add("\}") + v.add("BREAK_{v.escapemark_name(escapemark)}: (void)0;") + return + end + var cl = v.expr(self.n_expr, null) var it_meth = self.method_iterator assert it_meth != null @@ -2722,7 +2866,7 @@ redef class AIsaExpr redef fun expr(v) do var i = v.expr(self.n_expr, null) - return v.type_test(i, self.cast_type.as(not null)) + return v.type_test(i, self.cast_type.as(not null), "isa") end end @@ -2732,7 +2876,7 @@ redef class AAsCastExpr var i = v.expr(self.n_expr, null) if v.compiler.modelbuilder.toolcontext.opt_no_check_assert.value then return i - var cond = v.type_test(i, self.mtype.as(not null)) + var cond = v.type_test(i, self.mtype.as(not null), "as") v.add("if (!{cond}) \{") v.add_abort("Cast failed") v.add("\}")