X-Git-Url: http://nitlanguage.org diff --git a/src/global_compiler.nit b/src/global_compiler.nit index a110679..e09d040 100644 --- a/src/global_compiler.nit +++ b/src/global_compiler.nit @@ -35,9 +35,15 @@ redef class ToolContext # --no-cc var opt_no_cc: OptionBool = new OptionBool("Do not invoke C compiler", "--no-cc") + # --make-flags + var opt_make_flags: OptionString = new OptionString("Additional options to make", "--make-flags") + # --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") @@ -53,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_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 @@ -71,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 @@ -89,8 +100,10 @@ redef class ModelBuilder end end - # Compile until all runtime_functions are visited + # The main function of the C + compiler.compile_main_function + # Compile until all runtime_functions are visited while not compiler.todos.is_empty do var m = compiler.todos.shift self.toolcontext.info("Compile {m} ({compiler.seen.length-compiler.todos.length}/{compiler.seen.length})", 3) @@ -98,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) @@ -134,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" @@ -196,13 +211,15 @@ redef class ModelBuilder time0 = time1 self.toolcontext.info("*** COMPILING C ***", 1) - self.toolcontext.info("make -B -f {makename} -j 4", 2) + var makeflags = self.toolcontext.opt_make_flags.value + if makeflags == null then makeflags = "" + self.toolcontext.info("make -B -f {makename} -j 4 {makeflags}", 2) var res if self.toolcontext.verbose_level >= 3 then - res = sys.system("make -B -f {makename} -j 4 2>&1") + res = sys.system("make -B -f {makename} -j 4 {makeflags} 2>&1") else - res = sys.system("make -B -f {makename} -j 4 2>&1 >/dev/null") + res = sys.system("make -B -f {makename} -j 4 {makeflags} 2>&1 >/dev/null") end if res != 0 then toolcontext.error(null, "make failed! Error code: {res}.") @@ -216,7 +233,7 @@ end # Singleton that store the knowledge about the compilation process class GlobalCompiler # The main module of the program - var mainmodule: MModule + var mainmodule: MModule writable # The result of the RTA (used to know live types and methods) var runtime_type_analysis: RapidTypeAnalysis @@ -239,22 +256,31 @@ class GlobalCompiler self.live_primitive_types.add(t) end end + end - # Header declarations - self.compile_header - - # The main function of the C - self.compile_main_function + # 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 ") - # TODO: Better way to activate the GC + self.header.add_decl("#ifndef NOBOEHM") self.header.add_decl("#include ") - #self.header.add_decl("#define GC_MALLOC(x) calloc(1, (x))") + 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 @@ -482,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 @@ -493,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 @@ -509,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 @@ -581,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 @@ -618,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 @@ -883,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 @@ -942,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 @@ -1196,6 +1341,12 @@ class GlobalCompilerVisitor end end + fun compile_callsite(callsite: CallSite, args: Array[RuntimeVariable]): nullable RuntimeVariable + do + var ret = self.send(callsite.mproperty, args) + return ret + end + # Generate a polymorphic send for the method `m' and the arguments `args' fun send(m: MMethod, args: Array[RuntimeVariable]): nullable RuntimeVariable do @@ -1220,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 @@ -1270,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 @@ -1308,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 @@ -1338,7 +1468,7 @@ class GlobalCompilerVisitor recv = self.autoadapt(recv, recvtype) args = args.to_a - self.varargize(m.msignature.as(not null), args) + self.varargize(m, m.msignature.as(not null), args) if args.length != m.msignature.arity + 1 then # because of self add("printf(\"NOT YET IMPLEMENTED: Invalid arity for {m}. {args.length} arguments given.\\n\"); exit(1);") debug("NOT YET IMPLEMENTED: Invalid arity for {m}. {args.length} arguments given.") @@ -1366,7 +1496,7 @@ class GlobalCompilerVisitor # Transform varargs, in raw arguments, into a single argument of type Array # Note: this method modify the given `args` # If there is no vararg, then `args` is not modified. - fun varargize(msignature: MSignature, args: Array[RuntimeVariable]) + fun varargize(mpropdef: MPropDef, msignature: MSignature, args: Array[RuntimeVariable]) do var recv = args.first var vararg_rank = msignature.vararg_rank @@ -1386,10 +1516,9 @@ class GlobalCompilerVisitor for i in [vararg_rank..vararg_lastrank] do vararg.add(rawargs[i+1]) end - # FIXME: its it to late to determine the vararg type, this should have been done during a previous analysis + var elttype = msignature.mparameters[vararg_rank].mtype - elttype = self.resolve_for(elttype, recv) - args.add(self.array_instance(vararg, elttype)) + args.add(self.vararg_instance(mpropdef, recv, vararg, elttype)) for i in [vararg_lastrank+1..rawargs.length-1[ do args.add(rawargs[i+1]) @@ -1399,6 +1528,16 @@ class GlobalCompilerVisitor end end + # Get an instance of a anny for a vararg + fun vararg_instance(mpropdef: MPropDef, recv: RuntimeVariable, varargs: Array[RuntimeVariable], elttype: MType): RuntimeVariable + do + # FIXME: this is currently buggy since recv is not exact + + elttype = self.resolve_for(elttype, recv) + return self.array_instance(varargs, elttype) + end + + fun bugtype(recv: RuntimeVariable) do if recv.mtype.ctype != "val*" then return @@ -1548,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 @@ -1842,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) @@ -2125,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) @@ -2361,7 +2500,7 @@ redef class AVarReassignExpr var variable = self.variable.as(not null) var vari = v.variable(variable) var value = v.expr(self.n_value, variable.declared_type) - var res = v.send(reassign_property.mproperty, [vari, value]) + var res = v.compile_callsite(self.reassign_callsite.as(not null), [vari, value]) assert res != null v.assign(v.variable(variable), res) end @@ -2472,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 @@ -2701,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 @@ -2711,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("\}") @@ -2768,8 +2933,7 @@ redef class ASendExpr for a in self.raw_arguments.as(not null) do args.add(v.expr(a, null)) end - var mproperty = self.mproperty.as(not null) - return v.send(mproperty, args) + return v.compile_callsite(self.callsite.as(not null), args) end end @@ -2783,15 +2947,14 @@ redef class ASendReassignFormExpr end var value = v.expr(self.n_value, null) - var mproperty = self.mproperty.as(not null) - var left = v.send(mproperty, args) + var left = v.compile_callsite(self.callsite.as(not null), args) assert left != null - var res = v.send(reassign_property.mproperty, [left, value]) + var res = v.compile_callsite(self.reassign_callsite.as(not null), [left, value]) assert res != null args.add(res) - v.send(self.write_mproperty.as(not null), args) + v.compile_callsite(self.write_callsite.as(not null), args) end end @@ -2835,7 +2998,6 @@ end redef class ANewExpr redef fun expr(v) do - var mproperty = self.mproperty.as(not null) var mtype = self.mtype.as(MClassType) var recv var ctype = mtype.ctype @@ -2851,7 +3013,7 @@ redef class ANewExpr for a in self.n_args.n_exprs do args.add(v.expr(a, null)) end - var res2 = v.send(mproperty, args) + var res2 = v.compile_callsite(self.callsite.as(not null), args) if res2 != null then #self.debug("got {res2} from {mproperty}. drop {recv}") return res2 @@ -2887,7 +3049,7 @@ redef class AAttrReassignExpr var value = v.expr(self.n_value, null) var mproperty = self.mproperty.as(not null) var attr = v.read_attribute(mproperty, recv) - var res = v.send(reassign_property.mproperty, [attr, value]) + var res = v.compile_callsite(self.reassign_callsite.as(not null), [attr, value]) assert res != null v.write_attribute(mproperty, recv, res) end