X-Git-Url: http://nitlanguage.org diff --git a/src/separate_compiler.nit b/src/separate_compiler.nit index 7deac6a..f5dd05d 100644 --- a/src/separate_compiler.nit +++ b/src/separate_compiler.nit @@ -18,7 +18,6 @@ module separate_compiler import abstract_compiler import layout_builders import rapid_type_analysis -import collect_super_sends import compiler_ffi # Add separate compiler specific options @@ -95,6 +94,11 @@ redef class ModelBuilder 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.display_stats @@ -114,7 +118,6 @@ class SeparateCompiler var runtime_type_analysis: nullable RapidTypeAnalysis private var undead_types: Set[MType] = new HashSet[MType] - private var partial_types: Set[MType] = new HashSet[MType] private var live_unresolved_types: Map[MClassDef, Set[MType]] = new HashMap[MClassDef, HashSet[MType]] private var type_layout: nullable Layout[MType] @@ -271,13 +274,27 @@ class SeparateCompiler end end + # Collect all super calls (dead or not) + var all_super_calls = new HashSet[MMethodDef] + for mmodule in self.mainmodule.in_importation.greaters do + for mclassdef in mmodule.mclassdefs do + for mpropdef in mclassdef.mpropdefs do + if not mpropdef isa MMethodDef then continue + if mpropdef.has_supercall then + all_super_calls.add(mpropdef) + end + end + end + end + # lookup super calls and add it to the list of mmethods to build layout with var super_calls if runtime_type_analysis != null then super_calls = runtime_type_analysis.live_super_sends else - super_calls = modelbuilder.collect_super_sends + super_calls = all_super_calls end + for mmethoddef in super_calls do var mclass = mmethoddef.mclassdef.mclass mmethods[mclass].add(mmethoddef) @@ -292,14 +309,9 @@ class SeparateCompiler self.compile_color_consts(method_layout.pos) # attribute null color to dead supercalls - for mmodule in self.mainmodule.in_importation.greaters do - for mclassdef in mmodule.mclassdefs do - for mpropdef in mclassdef.mpropdefs do - if mpropdef.has_supercall then - compile_color_const(new_visitor, mpropdef, -1) - end - end - end + for mpropdef in all_super_calls do + if super_calls.has(mpropdef) then continue + compile_color_const(new_visitor, mpropdef, -1) end # attributes coloration @@ -443,16 +455,10 @@ class SeparateCompiler var mtypes = new HashSet[MType] mtypes.add_all(self.runtime_type_analysis.live_types) mtypes.add_all(self.runtime_type_analysis.live_cast_types) - mtypes.add_all(self.undead_types) for c in self.box_kinds.keys do mtypes.add(c.mclass_type) end - for mtype in mtypes do - retrieve_partial_types(mtype) - end - mtypes.add_all(self.partial_types) - # Typing Layout var layout_builder: TypingLayoutBuilder[MType] if modelbuilder.toolcontext.opt_bm_typing.value then @@ -581,34 +587,6 @@ class SeparateCompiler return tables end - fun retrieve_partial_types(mtype: MType) do - # add formal types arguments to mtypes - if mtype isa MGenericType then - for ft in mtype.arguments do - if ft.need_anchor then - print("Why do we need anchor here ?") - abort - end - self.partial_types.add(ft) - retrieve_partial_types(ft) - end - end - var mclass_type: MClassType - if mtype isa MNullableType then - mclass_type = mtype.mtype.as(MClassType) - else - mclass_type = mtype.as(MClassType) - end - - # add virtual types to mtypes - for vt in self.mainmodule.properties(mclass_type.mclass) do - if vt isa MVirtualTypeProp then - var anchored = vt.mvirtualtype.lookup_bound(self.mainmodule, mclass_type).anchor_to(self.mainmodule, mclass_type) - self.partial_types.add(anchored) - end - end - end - # Separately compile all the method definitions of the module fun compile_module_to_c(mmodule: MModule) do @@ -630,6 +608,10 @@ class SeparateCompiler # Globaly compile the type structure of a live type fun compile_type_to_c(mtype: MType) do + assert not mtype.need_anchor + var layout = self.type_layout + var is_live = mtype isa MClassType and runtime_type_analysis.live_types.has(mtype) + var is_cast_live = runtime_type_analysis.live_cast_types.has(mtype) var c_name = mtype.c_name var v = new SeparateCompilerVisitor(self) v.add_decl("/* runtime type {mtype} */") @@ -639,39 +621,70 @@ class SeparateCompiler # const struct type_X v.add_decl("const struct type type_{c_name} = \{") - v.add_decl("{self.type_layout.ids[mtype]},") + + # type id (for cast target) + if is_cast_live then + v.add_decl("{layout.ids[mtype]},") + else + v.add_decl("-1, /*CAST DEAD*/") + end + + # type name v.add_decl("\"{mtype}\", /* class_name_string */") - var layout = self.type_layout - if layout isa PHLayout[MType, MType] then - v.add_decl("{layout.masks[mtype]},") + + # type color (for cast target) + if is_cast_live then + if layout isa PHLayout[MType, MType] then + v.add_decl("{layout.masks[mtype]},") + else + v.add_decl("{layout.pos[mtype]},") + end else - v.add_decl("{layout.pos[mtype]},") + v.add_decl("-1, /*CAST DEAD*/") end + + # is_nullable bit if mtype isa MNullableType then v.add_decl("1,") else v.add_decl("0,") end - if compile_type_resolution_table(mtype) then - v.require_declaration("resolution_table_{c_name}") - v.add_decl("&resolution_table_{c_name},") + + # resolution table (for receiver) + if is_live then + var mclass_type = mtype + if mclass_type isa MNullableType then mclass_type = mclass_type.mtype + assert mclass_type isa MClassType + if resolution_tables[mclass_type].is_empty then + v.add_decl("NULL, /*NO RESOLUTIONS*/") + else + compile_type_resolution_table(mtype) + v.require_declaration("resolution_table_{c_name}") + v.add_decl("&resolution_table_{c_name},") + end else - v.add_decl("NULL,") + v.add_decl("NULL, /*DEAD*/") end - v.add_decl("{self.type_tables[mtype].length},") - v.add_decl("\{") - for stype in self.type_tables[mtype] do - if stype == null then - v.add_decl("-1, /* empty */") - else - v.add_decl("{self.type_layout.ids[stype]}, /* {stype} */") + + # cast table (for receiver) + if is_live then + v.add_decl("{self.type_tables[mtype].length},") + v.add_decl("\{") + for stype in self.type_tables[mtype] do + if stype == null then + v.add_decl("-1, /* empty */") + else + v.add_decl("{layout.ids[stype]}, /* {stype} */") + end end + v.add_decl("\},") + else + v.add_decl("0, \{\}, /*DEAD TYPE*/") end - v.add_decl("\},") v.add_decl("\};") end - fun compile_type_resolution_table(mtype: MType): Bool do + fun compile_type_resolution_table(mtype: MType) do var mclass_type: MClassType if mtype isa MNullableType then @@ -679,7 +692,6 @@ class SeparateCompiler else mclass_type = mtype.as(MClassType) end - if not self.resolution_tables.has_key(mclass_type) then return false var layout = self.resolution_layout @@ -714,7 +726,6 @@ class SeparateCompiler end v.add_decl("\}") v.add_decl("\};") - return true end # Globally compile the table of the class mclass @@ -724,6 +735,7 @@ class SeparateCompiler do var mtype = mclass.intro.bound_mtype var c_name = mclass.c_name + var c_instance_name = mclass.c_instance_name var vft = self.method_tables[mclass] var attrs = self.attr_tables[mclass] @@ -755,20 +767,22 @@ class SeparateCompiler end if mtype.ctype != "val*" then - #Build instance struct - self.header.add_decl("struct instance_{c_name} \{") - self.header.add_decl("const struct type *type;") - self.header.add_decl("const struct class *class;") - self.header.add_decl("{mtype.ctype} value;") - self.header.add_decl("\};") + if mtype.mclass.name == "Pointer" or mtype.mclass.kind != extern_kind then + #Build instance struct + self.header.add_decl("struct instance_{c_instance_name} \{") + self.header.add_decl("const struct type *type;") + self.header.add_decl("const struct class *class;") + self.header.add_decl("{mtype.ctype} value;") + self.header.add_decl("\};") + end if not self.runtime_type_analysis.live_types.has(mtype) then return #Build BOX - self.header.add_decl("val* BOX_{c_name}({mtype.ctype});") + self.provide_declaration("BOX_{c_name}", "val* BOX_{c_name}({mtype.ctype});") v.add_decl("/* allocate {mtype} */") v.add_decl("val* BOX_{mtype.c_name}({mtype.ctype} value) \{") - v.add("struct instance_{c_name}*res = nit_alloc(sizeof(struct instance_{c_name}));") + v.add("struct instance_{c_instance_name}*res = nit_alloc(sizeof(struct instance_{c_instance_name}));") v.require_declaration("type_{c_name}") v.add("res->type = &type_{c_name};") v.require_declaration("class_{c_name}") @@ -779,7 +793,7 @@ class SeparateCompiler return else if mclass.name == "NativeArray" then #Build instance struct - self.header.add_decl("struct instance_{c_name} \{") + self.header.add_decl("struct instance_{c_instance_name} \{") self.header.add_decl("const struct type *type;") self.header.add_decl("const struct class *class;") # NativeArrays are just a instance header followed by an array of values @@ -793,7 +807,7 @@ class SeparateCompiler var res = v.new_named_var(mtype, "self") res.is_exact = true var mtype_elt = mtype.arguments.first - v.add("{res} = nit_alloc(sizeof(struct instance_{c_name}) + length*sizeof({mtype_elt.ctype}));") + v.add("{res} = nit_alloc(sizeof(struct instance_{c_instance_name}) + length*sizeof({mtype_elt.ctype}));") v.add("{res}->type = type;") hardening_live_type(v, "type") v.require_declaration("class_{c_name}") @@ -903,8 +917,10 @@ class SeparateCompiler redef fun finalize_ffi_for_module(nmodule) do + var old_module = self.mainmodule self.mainmodule = nmodule.mmodule.as(not null) super + self.mainmodule = old_module end end @@ -937,7 +953,7 @@ class SeparateCompilerVisitor 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 instance_{mtype.c_name}*){value})->value; /* autounbox from {value.mtype} to {mtype} */", mtype) + return self.new_expr("((struct instance_{mtype.c_instance_name}*){value})->value; /* autounbox from {value.mtype} to {mtype} */", mtype) else if mtype.ctype == "val*" then var valtype = value.mtype.as(MClassType) var res = self.new_var(mtype) @@ -946,6 +962,7 @@ class SeparateCompilerVisitor self.add("printf(\"Dead code executed!\\n\"); show_backtrace(1);") return res end + self.require_declaration("BOX_{valtype.c_name}") self.add("{res} = BOX_{valtype.c_name}({value}); /* autobox from {value.mtype} to {mtype} */") return res else if value.mtype.cname_blind == "void*" and mtype.cname_blind == "void*" then @@ -966,6 +983,7 @@ class SeparateCompilerVisitor if value.mtype.ctype == "val*" then return "{value}->type" else + compiler.undead_types.add(value.mtype) self.require_declaration("type_{value.mtype.c_name}") return "(&type_{value.mtype.c_name})" end @@ -990,6 +1008,8 @@ class SeparateCompilerVisitor private fun table_send(mmethod: MMethod, arguments: Array[RuntimeVariable], const_color: String): nullable RuntimeVariable do + assert arguments.length == mmethod.intro.msignature.arity + 1 else debug("Invalid arity for {mmethod}. {arguments.length} arguments given.") + 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 @@ -1044,7 +1064,7 @@ class SeparateCompilerVisitor self.add("{res} = 1; /* {arg.inspect} cannot be null */") end else - self.add_abort("Reciever is null") + self.add_abort("Receiver is null") end self.add("\} else \{") end @@ -1085,6 +1105,8 @@ class SeparateCompilerVisitor redef fun call(mmethoddef, recvtype, arguments) do + assert arguments.length == mmethoddef.msignature.arity + 1 else debug("Invalid arity for {mmethoddef}. {arguments.length} arguments given.") + var res: nullable RuntimeVariable var ret = mmethoddef.msignature.return_mtype if mmethoddef.mproperty.is_new then @@ -1252,7 +1274,7 @@ class SeparateCompilerVisitor # The attribute is primitive, thus we store it in a box # The trick is to create the box the first time then resuse the box self.add("if ({attr} != NULL) \{") - self.add("((struct instance_{mtype.c_name}*){attr})->value = {value}; /* {a} on {recv.inspect} */") + self.add("((struct instance_{mtype.c_instance_name}*){attr})->value = {value}; /* {a} on {recv.inspect} */") self.add("\} else \{") value = self.autobox(value, self.object_type.as_nullable) self.add("{attr} = {value}; /* {a} on {recv.inspect} */") @@ -1520,12 +1542,12 @@ class SeparateCompilerVisitor end end if primitive != null then - test.add("((struct instance_{primitive.c_name}*){value1})->value == ((struct instance_{primitive.c_name}*){value2})->value") + test.add("((struct instance_{primitive.c_instance_name}*){value1})->value == ((struct instance_{primitive.c_instance_name}*){value2})->value") else if can_be_primitive(value1) and can_be_primitive(value2) then test.add("{value1}->class == {value2}->class") var s = new Array[String] for t, v in self.compiler.box_kinds do - s.add "({value1}->class->box_kind == {v} && ((struct instance_{t.c_name}*){value1})->value == ((struct instance_{t.c_name}*){value2})->value)" + s.add "({value1}->class->box_kind == {v} && ((struct instance_{t.c_instance_name}*){value1})->value == ((struct instance_{t.c_instance_name}*){value2})->value)" end test.add("({s.join(" || ")})") else @@ -1596,7 +1618,7 @@ class SeparateCompilerVisitor do var elttype = arguments.first.mtype var nclass = self.get_class("NativeArray") - var recv = "((struct instance_{nclass.c_name}*){arguments[0]})->values" + var recv = "((struct instance_{nclass.c_instance_name}*){arguments[0]})->values" if pname == "[]" then self.ret(self.new_expr("{recv}[{arguments[1]}]", ret_type.as(not null))) return @@ -1604,7 +1626,7 @@ class SeparateCompilerVisitor self.add("{recv}[{arguments[1]}]={arguments[2]};") return else if pname == "copy_to" then - var recv1 = "((struct instance_{nclass.c_name}*){arguments[1]})->values" + var recv1 = "((struct instance_{nclass.c_instance_name}*){arguments[1]})->values" self.add("memcpy({recv1}, {recv}, {arguments[2]}*sizeof({elttype.ctype}));") return end @@ -1809,6 +1831,23 @@ end redef class MType fun const_color: String do return "COLOR_{c_name}" + + # C name of the instance type to use + fun c_instance_name: String do return c_name +end + +redef class MClassType + redef fun c_instance_name do return mclass.c_instance_name +end + +redef class MClass + # Extern classes use the C instance of kernel::Pointer + fun c_instance_name: String + do + if kind == extern_kind then + return "kernel__Pointer" + else return c_name + end end redef class MProperty