X-Git-Url: http://nitlanguage.org diff --git a/src/compiler/separate_compiler.nit b/src/compiler/separate_compiler.nit index 7eed804..1f1cf67 100644 --- a/src/compiler/separate_compiler.nit +++ b/src/compiler/separate_compiler.nit @@ -90,45 +90,7 @@ redef class ModelBuilder self.toolcontext.info("*** GENERATING C ***", 1) var compiler = new SeparateCompiler(mainmodule, self, runtime_type_analysis) - compiler.compile_header - - # compile class structures - self.toolcontext.info("Property coloring", 2) - compiler.new_file("{mainmodule.name}.classes") - compiler.do_property_coloring - for m in mainmodule.in_importation.greaters do - for mclass in m.intro_mclasses do - if mclass.kind == abstract_kind or mclass.kind == interface_kind then continue - compiler.compile_class_to_c(mclass) - end - end - - # The main function of the C - compiler.new_file("{mainmodule.name}.main") - compiler.compile_nitni_global_ref_functions - compiler.compile_main_function - compiler.compile_finalizer_function - - # compile methods - for m in mainmodule.in_importation.greaters do - self.toolcontext.info("Generate C for module {m}", 2) - compiler.new_file("{m.name}.sep") - compiler.compile_module_to_c(m) - end - - # compile live & cast type structures - self.toolcontext.info("Type coloring", 2) - compiler.new_file("{mainmodule.name}.types") - var mtypes = compiler.do_type_coloring - for t in mtypes do - compiler.compile_type_to_c(t) - end - # compile remaining types structures (useless but needed for the symbol resolution at link-time) - for t in compiler.undead_types do - if mtypes.has(t) then continue - compiler.compile_type_to_c(t) - end - + compiler.do_compilation compiler.display_stats var time1 = get_time @@ -156,20 +118,72 @@ class SeparateCompiler private var undead_types: Set[MType] = new HashSet[MType] private var live_unresolved_types: Map[MClassDef, Set[MType]] = new HashMap[MClassDef, HashSet[MType]] - private var type_ids: Map[MType, Int] - private var type_colors: Map[MType, Int] - private var opentype_colors: Map[MType, Int] - protected var method_colors: Map[PropertyLayoutElement, Int] - protected var attr_colors: Map[MAttribute, Int] + private var type_ids: Map[MType, Int] is noinit + private var type_colors: Map[MType, Int] is noinit + private var opentype_colors: Map[MType, Int] is noinit + protected var method_colors: Map[PropertyLayoutElement, Int] is noinit + protected var attr_colors: Map[MAttribute, Int] is noinit - init(mainmodule: MModule, mmbuilder: ModelBuilder, runtime_type_analysis: nullable RapidTypeAnalysis) do - super(mainmodule, mmbuilder) + init do var file = new_file("nit.common") self.header = new CodeWriter(file) - self.runtime_type_analysis = runtime_type_analysis self.compile_box_kinds end + redef fun do_compilation + do + var compiler = self + compiler.compile_header + + var c_name = mainmodule.c_name + + # compile class structures + modelbuilder.toolcontext.info("Property coloring", 2) + compiler.new_file("{c_name}.classes") + compiler.do_property_coloring + for m in mainmodule.in_importation.greaters do + for mclass in m.intro_mclasses do + #if mclass.kind == abstract_kind or mclass.kind == interface_kind then continue + compiler.compile_class_to_c(mclass) + end + end + + # The main function of the C + compiler.new_file("{c_name}.main") + compiler.compile_nitni_global_ref_functions + compiler.compile_main_function + compiler.compile_finalizer_function + + # compile methods + for m in mainmodule.in_importation.greaters do + modelbuilder.toolcontext.info("Generate C for module {m.full_name}", 2) + compiler.new_file("{m.c_name}.sep") + compiler.compile_module_to_c(m) + end + + # compile live & cast type structures + modelbuilder.toolcontext.info("Type coloring", 2) + compiler.new_file("{c_name}.types") + compiler.compile_types + end + + # Color and compile type structures and cast information + fun compile_types + do + var compiler = self + + var mtypes = compiler.do_type_coloring + for t in mtypes do + compiler.compile_type_to_c(t) + end + # compile remaining types structures (useless but needed for the symbol resolution at link-time) + for t in compiler.undead_types do + if mtypes.has(t) then continue + compiler.compile_type_to_c(t) + end + + end + redef fun compile_header_structs do self.header.add_decl("typedef void(*nitmethod_t)(void); /* general C type representing a Nit method. */") self.compile_header_attribute_structs @@ -418,13 +432,12 @@ class SeparateCompiler var live_cast_types = runtime_type_analysis.live_cast_types var mtypes = new HashSet[MType] mtypes.add_all(live_types) - mtypes.add_all(live_cast_types) for c in self.box_kinds.keys do mtypes.add(c.mclass_type) end # Compute colors - var poset = poset_from_mtypes(mtypes) + var poset = poset_from_mtypes(mtypes, live_cast_types) var colorer = new POSetColorer[MType] colorer.colorize(poset) type_ids = colorer.ids @@ -437,12 +450,13 @@ class SeparateCompiler return poset end - private fun poset_from_mtypes(mtypes: Set[MType]): POSet[MType] do + private fun poset_from_mtypes(mtypes, cast_types: Set[MType]): POSet[MType] do var poset = new POSet[MType] for e in mtypes do poset.add_node(e) - for o in mtypes do + for o in cast_types do if e == o then continue + poset.add_node(o) if e.is_subtype(mainmodule, null, o) then poset.add_edge(e, o) end @@ -1063,12 +1077,11 @@ class SeparateCompilerVisitor do var rta = compiler.runtime_type_analysis var mmethod = callsite.mproperty - # TODO: Inlining of new-style constructors - if compiler.modelbuilder.toolcontext.opt_direct_call_monomorph.value and rta != null and not mmethod.is_root_init then + # TODO: Inlining of new-style constructors with initializers + if compiler.modelbuilder.toolcontext.opt_direct_call_monomorph.value and rta != null and callsite.mpropdef.initializers.is_empty then var tgs = rta.live_targets(callsite) if tgs.length == 1 then # DIRECT CALL - self.varargize(mmethod.intro, mmethod.intro.msignature.as(not null), args) var res0 = before_send(mmethod, args) var res = call(tgs.first, tgs.first.mclassdef.bound_mtype, args) if res0 != null then @@ -1084,8 +1097,6 @@ class SeparateCompilerVisitor end redef fun send(mmethod, arguments) do - self.varargize(mmethod.intro, mmethod.intro.msignature.as(not null), arguments) - if arguments.first.mcasttype.ctype != "val*" then # In order to shortcut the primitive, we need to find the most specific method # Howverr, because of performance (no flattening), we always work on the realmainmodule @@ -1115,10 +1126,10 @@ class SeparateCompilerVisitor var res: nullable RuntimeVariable = null var recv = arguments.first var consider_null = not self.compiler.modelbuilder.toolcontext.opt_no_check_null.value or mmethod.name == "==" or mmethod.name == "!=" - var maybenull = recv.mcasttype isa MNullableType and consider_null + var maybenull = (recv.mcasttype isa MNullableType or recv.mcasttype isa MNullType) and consider_null if maybenull then self.add("if ({recv} == NULL) \{") - if mmethod.name == "==" then + if mmethod.name == "==" or mmethod.name == "is_same_instance" then res = self.new_var(bool_type) var arg = arguments[1] if arg.mcasttype isa MNullableType then @@ -1145,15 +1156,15 @@ class SeparateCompilerVisitor else self.add("\{") end - if not self.compiler.modelbuilder.toolcontext.opt_no_shortcut_equate.value and (mmethod.name == "==" or mmethod.name == "!=") then - if res == null then res = self.new_var(bool_type) - # Recv is not null, thus is arg is, it is easy to conclude (and respect the invariants) + if not self.compiler.modelbuilder.toolcontext.opt_no_shortcut_equate.value and (mmethod.name == "==" or mmethod.name == "!=" or mmethod.name == "is_same_instance") then + # Recv is not null, thus if arg is, it is easy to conclude (and respect the invariants) var arg = arguments[1] if arg.mcasttype isa MNullType then - if mmethod.name == "==" then - self.add("{res} = 0; /* arg is null but recv is not */") - else + if res == null then res = self.new_var(bool_type) + if mmethod.name == "!=" then self.add("{res} = 1; /* arg is null and recv is not */") + else # `==` and `is_same_instance` + self.add("{res} = 0; /* arg is null but recv is not */") end self.add("\}") # closes the null case self.add("if (0) \{") # what follow is useless, CC will drop it @@ -1175,10 +1186,7 @@ class SeparateCompilerVisitor var res: nullable RuntimeVariable var msignature = mmethod.intro.msignature.resolve_for(mmethod.intro.mclassdef.bound_mtype, mmethod.intro.mclassdef.bound_mtype, mmethod.intro.mclassdef.mmodule, true) var ret = msignature.return_mtype - if mmethod.is_new then - ret = arguments.first.mtype - res = self.new_var(ret) - else if ret == null then + if ret == null then res = null else res = self.new_var(ret) @@ -1229,10 +1237,7 @@ class SeparateCompilerVisitor var res: nullable RuntimeVariable var ret = mmethoddef.msignature.return_mtype - if mmethoddef.mproperty.is_new then - ret = arguments.first.mtype - res = self.new_var(ret) - else if ret == null then + if ret == null then res = null else ret = ret.resolve_for(mmethoddef.mclassdef.bound_mtype, mmethoddef.mclassdef.bound_mtype, mmethoddef.mclassdef.mmodule, true) @@ -1243,7 +1248,7 @@ class SeparateCompilerVisitor (compiler.modelbuilder.toolcontext.opt_inline_some_methods.value and mmethoddef.can_inline(self)) then compiler.modelbuilder.nb_invok_by_inline += 1 if compiler.modelbuilder.toolcontext.opt_invocation_metrics.value then add("count_invoke_by_inline++;") - var frame = new Frame(self, mmethoddef, recvtype, arguments) + var frame = new StaticFrame(self, mmethoddef, recvtype, arguments) frame.returnlabel = self.get_name("RET_LABEL") frame.returnvar = res var old_frame = self.frame @@ -1293,11 +1298,11 @@ class SeparateCompilerVisitor # of the method (ie recv) if the static type is unresolved # This is more complex than usual because the unresolved type must not be resolved # with the current receiver (ie self). - # Therefore to isolate the resolution from self, a local Frame is created. + # Therefore to isolate the resolution from self, a local StaticFrame is created. # One can see this implementation as an inlined method of the receiver whose only # job is to allocate the array var old_frame = self.frame - var frame = new Frame(self, mpropdef, mpropdef.mclassdef.bound_mtype, [recv]) + var frame = new StaticFrame(self, mpropdef, mpropdef.mclassdef.bound_mtype, [recv]) self.frame = frame #print "required Array[{elttype}] for recv {recv.inspect}. bound=Array[{self.resolve_for(elttype, recv)}]. selfvar={frame.arguments.first.inspect}" var res = self.array_instance(varargs, elttype) @@ -1815,7 +1820,7 @@ class SeparateRuntimeFunction var v = compiler.new_visitor var selfvar = new RuntimeVariable("self", recv, recv) var arguments = new Array[RuntimeVariable] - var frame = new Frame(v, mmethoddef, recv, arguments) + var frame = new StaticFrame(v, mmethoddef, recv, arguments) v.frame = frame var msignature = mmethoddef.msignature.resolve_for(mmethoddef.mclassdef.bound_mtype, mmethoddef.mclassdef.bound_mtype, mmethoddef.mclassdef.mmodule, true) @@ -1825,9 +1830,6 @@ class SeparateRuntimeFunction var ret = msignature.return_mtype if ret != null then sig.append("{ret.ctype} ") - else if mmethoddef.mproperty.is_new then - ret = recv - sig.append("{ret.ctype} ") else sig.append("void ") end @@ -1890,7 +1892,7 @@ class VirtualRuntimeFunction var v = compiler.new_visitor var selfvar = new RuntimeVariable("self", v.object_type, recv) var arguments = new Array[RuntimeVariable] - var frame = new Frame(v, mmethoddef, recv, arguments) + var frame = new StaticFrame(v, mmethoddef, recv, arguments) v.frame = frame var sig = new FlatBuffer @@ -1902,9 +1904,6 @@ class VirtualRuntimeFunction var ret = msignature.return_mtype if ret != null then sig.append("{ret.ctype} ") - else if mmethoddef.mproperty.is_new then - ret = recv - sig.append("{ret.ctype} ") else sig.append("void ") end