X-Git-Url: http://nitlanguage.org diff --git a/src/global_compiler.nit b/src/global_compiler.nit index b19ab64..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 @@ -104,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) @@ -140,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" @@ -249,6 +258,14 @@ class GlobalCompiler end end + # 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 + fun compile_header do var v = self.header self.header.add_decl("#include ") @@ -491,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 @@ -502,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 @@ -518,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 @@ -919,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 @@ -978,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 @@ -1262,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 @@ -1312,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 @@ -1350,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 @@ -1599,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 @@ -1893,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) @@ -2523,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 @@ -2752,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 @@ -2762,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("\}")