X-Git-Url: http://nitlanguage.org diff --git a/src/global_compiler.nit b/src/global_compiler.nit index 49319cb..e09d040 100644 --- a/src/global_compiler.nit +++ b/src/global_compiler.nit @@ -35,13 +35,39 @@ 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") + + # --no-check-initialization + var opt_no_check_initialization: OptionBool = new OptionBool("Disable isset tests at the end of constructors (dangerous)", "--no-check-initialization") + + # --no-check-assert + 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") + + # --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 @@ -55,47 +81,20 @@ redef class ModelBuilder self.toolcontext.info("*** COMPILING TO C ***", 1) var compiler = new GlobalCompiler(mainmodule, runtime_type_analysis, self) - var v = new GlobalCompilerVisitor(compiler) - - v.add_decl("#include ") - v.add_decl("#include ") - v.add_decl("#include ") + compiler.compile_header + var v = compiler.header - # TODO: Better way to activate the GC - v.add_decl("#include ") - #v.add_decl("#define GC_MALLOC(x) calloc(1, (x))") - - # Declaration of structures the live Nit types - # Each live type is generated as an independent C `struct' type. - # They only share a common first field `classid` used to implement the polymorphism. - # Usualy, all C variables that refers to a Nit object are typed on the abstract struct `val' that contains only the `classid` field. - - v.add_decl("typedef struct \{int classid;\} val; /* general C type representing a Nit instance. */") for t in runtime_type_analysis.live_types do compiler.declare_runtimeclass(v, t) end - # Global variable used by the legacy native interface - - v.add_decl("extern int glob_argc;") - v.add_decl("extern char **glob_argv;") - v.add_decl("extern val *glob_sys;") - - # Class names (for the class_name and output_class_name methods) - - v.add_decl("extern const char const * class_names[];") - v.add("const char const * class_names[] = \{") - for t in runtime_type_analysis.live_types do - v.add("\"{t}\", /* {compiler.classid(t)} */") - end - v.add("\};") - compiler.header = v + compiler.compile_class_names # Init instance code (allocate and init-arguments) - for t in runtime_type_analysis.live_types do if t.ctype == "val*" then compiler.generate_init_instance(t) + compiler.generate_check_init_instance(t) else compiler.generate_box_instance(t) end @@ -105,7 +104,6 @@ redef class ModelBuilder 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) @@ -113,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) @@ -149,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" @@ -211,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}.") @@ -231,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 @@ -244,6 +246,7 @@ class GlobalCompiler init(mainmodule: MModule, runtime_type_analysis: RapidTypeAnalysis, modelbuilder: ModelBuilder) do + self.header = new_visitor self.mainmodule = mainmodule self.runtime_type_analysis = runtime_type_analysis self.modelbuilder = modelbuilder @@ -255,6 +258,56 @@ 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 ") + 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 + + # Global variable used by the legacy native interface + self.header.add_decl("extern int glob_argc;") + self.header.add_decl("extern char **glob_argv;") + self.header.add_decl("extern val *glob_sys;") + end + + # Class names (for the class_name and output_class_name methods) + protected fun compile_class_names do + self.header.add_decl("extern const char const * class_names[];") + self.header.add("const char const * class_names[] = \{") + for t in self.runtime_type_analysis.live_types do + self.header.add("\"{t}\", /* {self.classid(t)} */") + end + self.header.add("\};") + end + + # Declaration of structures the live Nit types + # Each live type is generated as an independent C `struct' type. + # They only share a common first field `classid` used to implement the polymorphism. + # Usualy, all C variables that refers to a Nit object are typed on the abstract struct `val' that contains only the `classid` field. + protected fun compile_header_structs do + self.header.add_decl("typedef struct \{int classid;\} val; /* general C type representing a Nit instance. */") + end + # Subset of runtime_type_analysis.live_types that contains only primitive types # Used to implement the equal test var live_primitive_types: Array[MClassType] @@ -275,7 +328,7 @@ class GlobalCompiler # # FIXME: should not be a vistor but just somewhere to store lines # FIXME: should not have a global .h since it does not help recompilations - var header: nullable GlobalCompilerVisitor writable = null + var header: GlobalCompilerVisitor writable # The list of all associated visitors # Used to generate .c files @@ -342,7 +395,7 @@ class GlobalCompiler do assert self.runtime_type_analysis.live_types.has(mtype) assert mtype.ctype == "val*" - var v = new GlobalCompilerVisitor(self) + var v = self.new_visitor var is_native_array = mtype.mclass.name == "NativeArray" @@ -366,24 +419,57 @@ class GlobalCompiler end v.add("{res}->classid = {self.classid(mtype)};") + self.generate_init_attr(v, res, mtype) + v.add("return {res};") + v.add("\}") + end + + fun generate_check_init_instance(mtype: MClassType) + do + if self.modelbuilder.toolcontext.opt_no_check_initialization.value then return + + var v = self.new_visitor + var res = new RuntimeVariable("self", mtype, mtype) + self.header.add_decl("void CHECK_NEW_{mtype.c_name}({mtype.ctype});") + v.add_decl("/* allocate {mtype} */") + v.add_decl("void CHECK_NEW_{mtype.c_name}({mtype.ctype} {res}) \{") + self.generate_check_attr(v, res, mtype) + v.add("\}") + end + + # Generate code that collect initialize the attributes on a new instance + fun generate_init_attr(v: GlobalCompilerVisitor, recv: RuntimeVariable, mtype: MClassType) + do for cd in mtype.collect_mclassdefs(self.mainmodule) do var n = self.modelbuilder.mclassdef2nclassdef[cd] for npropdef in n.n_propdefs do if npropdef isa AAttrPropdef then - npropdef.init_expr(v, res) + npropdef.init_expr(v, recv) + end + end + end + end + + # Generate a check-init-instance + fun generate_check_attr(v: GlobalCompilerVisitor, recv: RuntimeVariable, mtype: MClassType) + do + for cd in mtype.collect_mclassdefs(self.mainmodule) + do + var n = self.modelbuilder.mclassdef2nclassdef[cd] + for npropdef in n.n_propdefs do + if npropdef isa AAttrPropdef then + npropdef.check_expr(v, recv) end end end - v.add("return {res};") - v.add("\}") end fun generate_box_instance(mtype: MClassType) do assert self.runtime_type_analysis.live_types.has(mtype) assert mtype.ctype != "val*" - var v = new GlobalCompilerVisitor(self) + var v = self.new_visitor self.header.add_decl("val* BOX_{mtype.c_name}({mtype.ctype});") v.add_decl("/* allocate {mtype} */") @@ -422,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 @@ -433,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 @@ -449,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 @@ -521,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 @@ -558,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 @@ -574,28 +775,6 @@ redef class MGenericType end end -redef class MParameterType - redef fun c_name - do - var res = self.c_name_cache - if res != null then return res - res = "FT{self.rank}" - self.c_name_cache = res - return res - end -end - -redef class MNullableType - redef fun c_name - do - var res = self.c_name_cache - if res != null then return res - res = "nullable_{self.mtype.c_name}" - self.c_name_cache = res - return res - end -end - # A C function associated to a Nit method # Because of customization, a given Nit method can be compiler more that once abstract class AbstractRuntimeFunction @@ -689,7 +868,7 @@ private class CustomizedRuntimeFunction abort end - var v = new GlobalCompilerVisitor(compiler) + var v = compiler.new_visitor var selfvar = new RuntimeVariable("self", recv, recv) if compiler.runtime_type_analysis.live_types.has(recv) then selfvar.is_exact = true @@ -845,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 @@ -904,6 +1085,15 @@ 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, "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 end @@ -933,7 +1123,9 @@ class GlobalCompilerVisitor # ENSURE: result.mtype.ctype == mtype.ctype fun autobox(value: RuntimeVariable, mtype: MType): RuntimeVariable do - if value.mtype.ctype == mtype.ctype then + if value.mtype == mtype then + return value + else if value.mtype.ctype == "val*" and mtype.ctype == "val*" then return value else if value.mtype.ctype == "val*" then return self.new_expr("((struct {mtype.c_name}*){value})->value; /* autounbox from {value.mtype} to {mtype} */", mtype) @@ -1139,6 +1331,8 @@ class GlobalCompilerVisitor # Add a check and an abort for a null reciever is needed fun check_recv_notnull(recv: RuntimeVariable) do + if self.compiler.modelbuilder.toolcontext.opt_no_check_other.value then return + var maybenull = recv.mcasttype isa MNullableType or recv.mcasttype isa MNullType if maybenull then self.add("if ({recv} == NULL) \{") @@ -1147,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 @@ -1171,18 +1371,13 @@ 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 end - if args.first.mcasttype isa MNullableType or args.first.mcasttype isa MNullType then + var consider_null = not self.compiler.modelbuilder.toolcontext.opt_no_check_other.value or m.name == "==" or m.name == "!=" + if args.first.mcasttype isa MNullableType or args.first.mcasttype isa MNullType and consider_null then # The reciever is potentially null, so we have to 3 cases: ==, != or NullPointerException self.add("if ({args.first} == NULL) \{ /* Special null case */") if m.name == "==" then @@ -1209,7 +1404,10 @@ class GlobalCompilerVisitor self.add "\} else" end if types.is_empty then + self.add("\{") self.add("/*BUG: no live types for {args.first.inspect} . {m}*/") + self.bugtype(args.first) + self.add("\}") return res end @@ -1217,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 @@ -1255,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 @@ -1285,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.") @@ -1313,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 @@ -1333,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]) @@ -1346,10 +1528,21 @@ 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 self.add("fprintf(stderr, \"BTD BUG: Dynamic type is %s, static type is %s\\n\", class_names[{recv}->classid], \"{recv.mcasttype}\");") + self.add("exit(1);") end # Generate a polymorphic attribute is_set test @@ -1363,6 +1556,7 @@ class GlobalCompilerVisitor if types.is_empty then self.add("/*BUG: no live types for {recv.inspect} . {a}*/") + self.bugtype(recv) return res end self.add("/* isset {a} on {recv.inspect} */") @@ -1409,6 +1603,7 @@ class GlobalCompilerVisitor if types.is_empty then self.add("/*BUG: no live types for {recv.inspect} . {a}*/") + self.bugtype(recv) return res end self.add("/* read {a} on {recv.inspect} */") @@ -1424,7 +1619,7 @@ class GlobalCompilerVisitor var ta = a.intro.static_mtype.as(not null) ta = self.resolve_for(ta, recv2) var res2 = self.new_expr("((struct {t.c_name}*){recv})->{a.intro.c_name}", ta) - if not ta isa MNullableType then + if not ta isa MNullableType and not self.compiler.modelbuilder.toolcontext.opt_no_check_other.value then if ta.ctype == "val*" then self.add("if ({res2} == NULL) \{") self.add_abort("Uninitialized attribute {a.name}") @@ -1454,6 +1649,7 @@ class GlobalCompilerVisitor if types.is_empty then self.add("/*BUG: no live types for {recv.inspect} . {a}*/") + self.bugtype(recv) return end self.add("/* write {a} on {recv.inspect} */") @@ -1491,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 @@ -1585,7 +1781,7 @@ class GlobalCompilerVisitor value2 = tmp end if value1.mtype.ctype != "val*" then - if value2.mtype.ctype == value1.mtype.ctype then + if value2.mtype == value1.mtype then self.add("{res} = {value1} == {value2};") else if value2.mtype.ctype != "val*" then self.add("{res} = 0; /* incompatible types {value1.mtype} vs. {value2.mtype}*/") @@ -1613,19 +1809,16 @@ class GlobalCompilerVisitor end # Generate a check-init-instance - fun check_init_instance(recv: RuntimeVariable) + fun check_init_instance(recv: RuntimeVariable, mtype: MClassType) do - var mtype = self.anchor(recv.mcasttype) - for cd in mtype.collect_mclassdefs(self.compiler.mainmodule) - do - var n = self.compiler.modelbuilder.mclassdef2nclassdef[cd] - for npropdef in n.n_propdefs do - if npropdef isa AAttrPropdef then - # Force read to check the initialization - self.read_attribute(npropdef.mpropdef.mproperty, recv) - end - end + if self.compiler.modelbuilder.toolcontext.opt_no_check_initialization.value then return + + mtype = self.anchor(mtype).as(MClassType) + if not self.compiler.runtime_type_analysis.live_types.has(mtype) then + debug "problem: {mtype} was detected dead" end + + self.add("CHECK_NEW_{mtype.c_name}({recv});") end # Generate an integer value @@ -1652,7 +1845,7 @@ class GlobalCompilerVisitor end var length = self.int_instance(array.length) self.send(self.get_property("with_native", arraytype), [res, nat, length]) - self.check_init_instance(res) + self.check_init_instance(res, arraytype) self.add("\}") return res end @@ -1673,7 +1866,7 @@ class GlobalCompilerVisitor self.add("{res} = {res2};") var length = self.int_instance(string.length) self.send(self.get_property("with_native", mtype), [res, nat, length]) - self.check_init_instance(res) + self.check_init_instance(res, mtype) self.add("{name} = {res};") self.add("\}") return res @@ -1772,6 +1965,8 @@ redef class MMethodDef # Generate type checks in the C code to check covariant parameters fun compile_parameter_check(v: GlobalCompilerVisitor, arguments: Array[RuntimeVariable]) do + if v.compiler.modelbuilder.toolcontext.opt_no_check_covariance.value then return + for i in [0..msignature.arity[ do # skip test for vararg since the array is instantiated with the correct polymorphic type if msignature.vararg_rank == i then continue @@ -1786,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) @@ -2069,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) @@ -2088,6 +2283,9 @@ redef class AInternMethPropdef var nat = v.class_name_string(arguments.first) v.ret(v.new_expr("(char*){nat}", ret.as(not null))) return + else if pname == "force_garbage_collection" then + v.add("GC_gcollect();") + return end v.add("printf(\"NOT YET IMPLEMENTED {class_name}:{mpropdef} at {location.to_s}\\n\");") debug("Not implemented {mpropdef}") @@ -2166,14 +2364,33 @@ redef class AAttrPropdef do var nexpr = self.n_expr if nexpr != null then + var oldnode = v.current_node + v.current_node = self var old_frame = v.frame var frame = new Frame(v, self.mpropdef.as(not null), recv.mtype.as(MClassType), [recv]) v.frame = frame var value = v.expr(nexpr, self.mpropdef.static_mtype) v.write_attribute(self.mpropdef.mproperty, recv, value) v.frame = old_frame + v.current_node = oldnode end end + + fun check_expr(v: GlobalCompilerVisitor, recv: RuntimeVariable) + do + var nexpr = self.n_expr + if nexpr != null then return + + var oldnode = v.current_node + v.current_node = self + var old_frame = v.frame + var frame = new Frame(v, self.mpropdef.as(not null), recv.mtype.as(MClassType), [recv]) + v.frame = frame + # Force read to check the initialization + v.read_attribute(self.mpropdef.mproperty, recv) + v.frame = old_frame + v.current_node = oldnode + end end redef class AClassdef @@ -2217,7 +2434,6 @@ redef class AExpr # Do not call this method directly, use `v.expr' instead private fun expr(v: GlobalCompilerVisitor): nullable RuntimeVariable do - debug("Unimplemented expr {class_name}") v.add("printf(\"NOT YET IMPLEMENTED {class_name}:{location.to_s}\\n\");") var mtype = self.mtype if mtype == null then @@ -2284,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 @@ -2395,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 @@ -2439,6 +2681,8 @@ end redef class AAssertExpr redef fun stmt(v) do + if v.compiler.modelbuilder.toolcontext.opt_no_check_assert.value then return + var cond = v.expr_bool(self.n_expr) v.add("if (!{cond}) \{") v.stmt(self.n_else) @@ -2575,9 +2819,10 @@ redef class ACrangeExpr do var i1 = v.expr(self.n_expr, null) var i2 = v.expr(self.n_expr2, null) - var res = v.init_instance(self.mtype.as(MClassType)) + var mtype = self.mtype.as(MClassType) + var res = v.init_instance(mtype) var it = v.send(v.get_property("init", res.mtype), [res, i1, i2]) - v.check_init_instance(res) + v.check_init_instance(res, mtype) return res end end @@ -2587,9 +2832,10 @@ redef class AOrangeExpr do var i1 = v.expr(self.n_expr, null) var i2 = v.expr(self.n_expr2, null) - var res = v.init_instance(self.mtype.as(MClassType)) + var mtype = self.mtype.as(MClassType) + var res = v.init_instance(mtype) var it = v.send(v.get_property("without_last", res.mtype), [res, i1, i2]) - v.check_init_instance(res) + v.check_init_instance(res, mtype) return res end end @@ -2620,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 @@ -2628,7 +2874,9 @@ redef class AAsCastExpr redef fun expr(v) do var i = v.expr(self.n_expr, null) - var cond = v.type_test(i, self.mtype.as(not 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), "as") v.add("if (!{cond}) \{") v.add_abort("Cast failed") v.add("\}") @@ -2640,6 +2888,8 @@ redef class AAsNotnullExpr redef fun expr(v) do var i = v.expr(self.n_expr, null) + if v.compiler.modelbuilder.toolcontext.opt_no_check_assert.value then return i + v.add("if ({i} == NULL) \{") v.add_abort("Cast failed") v.add("\}") @@ -2683,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 @@ -2698,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 @@ -2750,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 @@ -2766,12 +3013,12 @@ 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 end - v.check_init_instance(recv) + v.check_init_instance(recv, mtype) return recv end end @@ -2802,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