X-Git-Url: http://nitlanguage.org diff --git a/src/separate_erasure_compiler.nit b/src/separate_erasure_compiler.nit index fee575a..af3a43c 100644 --- a/src/separate_erasure_compiler.nit +++ b/src/separate_erasure_compiler.nit @@ -32,6 +32,15 @@ redef class ToolContext self.option_context.add_option(self.opt_erasure, self.opt_no_check_erasure_cast, opt_rta) end + redef fun process_options(args) + do + super + + if opt_no_check_all.value then + opt_no_check_erasure_cast.value = true + end + end + var erasure_compiler_phase = new ErasureCompilerPhase(self, null) end @@ -67,10 +76,11 @@ redef class ModelBuilder compiler.compile_class_to_c(mclass) end end - compiler.compile_color_consts(compiler.vt_layout.pos) + compiler.compile_color_consts(compiler.vt_colors) # The main function of the C compiler.new_file("{mainmodule.name}.main") + compiler.compile_nitni_global_ref_functions compiler.compile_main_function # compile methods @@ -91,18 +101,20 @@ end class SeparateErasureCompiler super SeparateCompiler - private var class_layout: nullable Layout[MClass] - protected var vt_layout: nullable Layout[MVirtualTypeProp] + private var class_ids: Map[MClass, Int] + private var class_colors: Map[MClass, Int] + protected var vt_colors: Map[MVirtualTypeProp, Int] init(mainmodule: MModule, mmbuilder: ModelBuilder, runtime_type_analysis: nullable RapidTypeAnalysis) do super # Class coloring - var mclasses = new HashSet[MClass].from(mmbuilder.model.mclasses) var poset = mainmodule.flatten_mclass_hierarchy + var mclasses = new HashSet[MClass].from(poset) var colorer = new POSetColorer[MClass] colorer.colorize(poset) - class_layout = colorer.to_layout + class_ids = colorer.ids + class_colors = colorer.colors class_tables = self.build_class_typing_tables(mclasses) # lookup vt to build layout with @@ -117,15 +129,12 @@ class SeparateErasureCompiler end # vt coloration - var class_colorer = new MClassColorer(mainmodule) - class_colorer.build_layout(mclasses) - var vt_coloring = new MPropertyColorer[MVirtualTypeProp](mainmodule, class_colorer) - var vt_layout = vt_coloring.build_layout(vts) - self.vt_tables = build_vt_tables(mclasses, vt_layout) - self.vt_layout = vt_layout + var vt_colorer = new POSetBucketsColorer[MClass, MVirtualTypeProp](poset, colorer.conflicts) + vt_colors = vt_colorer.colorize(vts) + vt_tables = build_vt_tables(mclasses) end - fun build_vt_tables(mclasses: Set[MClass], layout: Layout[MProperty]): Map[MClass, Array[nullable MPropDef]] do + fun build_vt_tables(mclasses: Set[MClass]): Map[MClass, Array[nullable MPropDef]] do var tables = new HashMap[MClass, Array[nullable MPropDef]] for mclass in mclasses do var table = new Array[nullable MPropDef] @@ -139,7 +148,7 @@ class SeparateErasureCompiler if parent == mclass then continue for mproperty in self.mainmodule.properties(parent) do if not mproperty isa MVirtualTypeProp then continue - var color = layout.pos[mproperty] + var color = vt_colors[mproperty] if table.length <= color then for i in [table.length .. color[ do table[i] = null @@ -156,7 +165,7 @@ class SeparateErasureCompiler # then override with local properties for mproperty in self.mainmodule.properties(mclass) do if not mproperty isa MVirtualTypeProp then continue - var color = layout.pos[mproperty] + var color = vt_colors[mproperty] if table.length <= color then for i in [table.length .. color[ do table[i] = null @@ -176,7 +185,6 @@ class SeparateErasureCompiler # Build class tables fun build_class_typing_tables(mclasses: Set[MClass]): Map[MClass, Array[nullable MClass]] do var tables = new HashMap[MClass, Array[nullable MClass]] - var layout = self.class_layout for mclass in mclasses do var table = new Array[nullable MClass] var supers = new Array[MClass] @@ -184,12 +192,7 @@ class SeparateErasureCompiler supers = mclass.in_hierarchy(mainmodule).greaters.to_a end for sup in supers do - var color: Int - if layout isa PHLayout[MClass, MClass] then - color = layout.hashes[mclass][sup] - else - color = layout.pos[sup] - end + var color = class_colors[sup] if table.length <= color then for i in [table.length .. color[ do table[i] = null @@ -208,13 +211,7 @@ class SeparateErasureCompiler self.header.add_decl("struct class \{ int id; const char *name; int box_kind; int color; const struct vts_table *vts_table; const struct type_table *type_table; nitmethod_t vft[]; \}; /* general C type representing a Nit class. */") self.header.add_decl("struct type_table \{ int size; int table[]; \}; /* colorized type table. */") self.header.add_decl("struct vts_entry \{ short int is_nullable; const struct class *class; \}; /* link (nullable or not) between the vts and is bound. */") - - if self.vt_layout isa PHLayout[MClass, MVirtualTypeProp] then - self.header.add_decl("struct vts_table \{ int mask; const struct vts_entry vts[]; \}; /* vts list of a C type representation. */") - else - self.header.add_decl("struct vts_table \{ int dummy; const struct vts_entry vts[]; \}; /* vts list of a C type representation. */") - end - + self.header.add_decl("struct vts_table \{ int dummy; const struct vts_entry vts[]; \}; /* vts list of a C type representation. */") self.header.add_decl("typedef struct instance \{ const struct class *class; nitattribute_t attrs[1]; \} val; /* general C type representing a Nit instance. */") end @@ -222,7 +219,6 @@ class SeparateErasureCompiler 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] @@ -242,15 +238,10 @@ class SeparateErasureCompiler # Build class vft v.add_decl("const struct class class_{c_name} = \{") - v.add_decl("{self.class_layout.ids[mclass]},") + v.add_decl("{class_ids[mclass]},") v.add_decl("\"{mclass.name}\", /* class_name_string */") v.add_decl("{self.box_kind_of(mclass)}, /* box_kind */") - var layout = self.class_layout - if layout isa PHLayout[MClass, MClass] then - v.add_decl("{layout.masks[mclass]},") - else - v.add_decl("{layout.pos[mclass]},") - end + v.add_decl("{class_colors[mclass]},") if not is_dead then if build_class_vts_table(mclass) then v.require_declaration("vts_table_{c_name}") @@ -292,31 +283,48 @@ class SeparateErasureCompiler if msuper == null then v.add_decl("-1, /* empty */") else - v.add_decl("{self.class_layout.ids[msuper]}, /* {msuper} */") + v.add_decl("{self.class_ids[msuper]}, /* {msuper} */") end end v.add_decl("\}") v.add_decl("\};") - if mtype.ctype != "val*" then - 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 class *class;") - self.header.add_decl("{mtype.ctype} value;") - self.header.add_decl("\};") - end + if mtype.ctype != "val*" or mtype.mclass.name == "Pointer" then + #Build instance struct + self.header.add_decl("struct instance_{c_name} \{") + self.header.add_decl("const struct class *class;") + self.header.add_decl("{mtype.ctype} value;") + self.header.add_decl("\};") #Build BOX 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_instance_name}*res = nit_alloc(sizeof(struct instance_{c_instance_name}));") + v.add("struct instance_{c_name}*res = nit_alloc(sizeof(struct instance_{c_name}));") v.require_declaration("class_{c_name}") v.add("res->class = &class_{c_name};") v.add("res->value = value;") v.add("return (val*)res;") v.add("\}") + + if mtype.mclass.name != "Pointer" then return + + v = new_visitor + self.provide_declaration("NEW_{c_name}", "{mtype.ctype} NEW_{c_name}();") + v.add_decl("/* allocate {mtype} */") + v.add_decl("{mtype.ctype} NEW_{c_name}() \{") + if is_dead then + v.add_abort("{mclass} is DEAD") + else + var res = v.new_named_var(mtype, "self") + res.is_exact = true + v.add("{res} = nit_alloc(sizeof(struct instance_{mtype.c_name}));") + v.require_declaration("class_{c_name}") + v.add("{res}->class = &class_{c_name};") + v.add("((struct instance_{mtype.c_name}*){res})->value = NULL;") + v.add("return {res};") + end + v.add("\}") return else if mclass.name == "NativeArray" then #Build instance struct @@ -340,6 +348,26 @@ class SeparateErasureCompiler v.add("return (val*){res};") v.add("\}") return + else if mtype.mclass.kind == extern_kind and mtype.mclass.name != "NativeString" then + var pointer_type = mainmodule.pointer_type + + self.provide_declaration("NEW_{c_name}", "{mtype.ctype} NEW_{c_name}();") + v.add_decl("/* allocate {mtype} */") + v.add_decl("{mtype.ctype} NEW_{c_name}() \{") + if is_dead then + v.add_abort("{mclass} is DEAD") + else + var res = v.new_named_var(mtype, "self") + res.is_exact = true + v.add("{res} = nit_alloc(sizeof(struct instance_{pointer_type.c_name}));") + #v.add("{res}->type = type;") + v.require_declaration("class_{c_name}") + v.add("{res}->class = &class_{c_name};") + v.add("((struct instance_{pointer_type.c_name}*){res})->value = NULL;") + v.add("return {res};") + end + v.add("\}") + return end #Build NEW @@ -356,6 +384,7 @@ class SeparateErasureCompiler v.require_declaration("class_{c_name}") v.add("{res}->class = &class_{c_name};") self.generate_init_attr(v, res, mtype) + v.set_finalizer res v.add("return {res};") end v.add("\}") @@ -368,12 +397,7 @@ class SeparateErasureCompiler var v = new_visitor v.add_decl("const struct vts_table vts_table_{mclass.c_name} = \{") - if self.vt_layout isa PHLayout[MClass, MVirtualTypeProp] then - #TODO redo this when PHPropertyLayoutBuilder will be implemented - #v.add_decl("{vt_masks[mclass]},") - else - v.add_decl("0, /* dummy */") - end + v.add_decl("0, /* dummy */") v.add_decl("\{") for vt in self.vt_tables[mclass] do @@ -476,7 +500,7 @@ class SeparateErasureCompilerVisitor self.add("if (!{cond}) \{") #var x = self.class_name_string(res) #var y = self.class_name_string(arguments.first) - #self.add("fprintf(stderr, \"Erasure cast: expected {mtype} (self is %s), got %s for {res}\\n\", {y}, {x});") + #self.add("PRINT_ERROR(\"Erasure cast: expected {mtype} (self is %s), got %s for {res}\\n\", {y}, {x});") self.add_abort("Cast failed") self.add("\}") end @@ -555,11 +579,7 @@ class SeparateErasureCompilerVisitor var entry = self.get_name("entry") self.add("struct vts_entry {entry};") self.require_declaration(mtype.mproperty.const_color) - if self.compiler.as(SeparateErasureCompiler).vt_layout isa PHLayout[MClass, MVirtualTypeProp] then - self.add("{entry} = {recv_ptr}vts_table->vts[HASH({recv_ptr}vts_table->mask, {mtype.mproperty.const_color})];") - else - self.add("{entry} = {recv_ptr}vts_table->vts[{mtype.mproperty.const_color}];") - end + self.add("{entry} = {recv_ptr}vts_table->vts[{mtype.mproperty.const_color}];") self.add("{cltype} = {entry}.class->color;") self.add("{idtype} = {entry}.class->id;") if maybe_null and accept_null == "0" then @@ -583,9 +603,6 @@ class SeparateErasureCompilerVisitor self.add("{res} = {accept_null};") self.add("\} else \{") end - if self.compiler.as(SeparateErasureCompiler).class_layout isa PHLayout[MClass, MClass] then - self.add("{cltype} = HASH({class_ptr}color, {idtype});") - end self.add("if({cltype} >= {class_ptr}type_table->size) \{") self.add("{res} = 0;") self.add("\} else \{") @@ -598,6 +615,40 @@ class SeparateErasureCompilerVisitor return res end + redef fun unbox_extern(value, mtype) + do + if mtype isa MClassType and mtype.mclass.kind == extern_kind and + mtype.mclass.name != "NativeString" then + var pointer_type = compiler.mainmodule.pointer_type + var res = self.new_var_extern(mtype) + self.add "{res} = ((struct instance_{pointer_type.c_name}*){value})->value; /* unboxing {value.mtype} */" + return res + else + return value + end + end + + redef fun box_extern(value, mtype) + do + if mtype isa MClassType and mtype.mclass.kind == extern_kind and + mtype.mclass.name != "NativeString" then + var valtype = compiler.mainmodule.pointer_type + var res = self.new_var(mtype) + if compiler.runtime_type_analysis != null and not compiler.runtime_type_analysis.live_types.has(value.mtype.as(MClassType)) then + self.add("/*no boxing of {value.mtype}: {value.mtype} is not live! */") + self.add("PRINT_ERROR(\"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}); /* boxing {value.mtype} */") + self.require_declaration("class_{mtype.c_name}") + self.add("{res}->class = &class_{mtype.c_name};") + return res + else + return value + end + end + redef fun class_name_string(value) do var res = self.get_name("var_class_name") @@ -611,24 +662,14 @@ class SeparateErasureCompilerVisitor return res end - redef fun array_instance(array, elttype) + redef fun native_array_instance(elttype, length) do var nclass = self.get_class("NativeArray") - elttype = self.anchor(elttype) - var arraytype = self.get_class("Array").get_mtype([elttype]) - var res = self.init_instance(arraytype) - self.add("\{ /* {res} = array_instance Array[{elttype}] */") - var nat = self.new_var(self.get_class("NativeArray").get_mtype([elttype])) - nat.is_exact = true + var mtype = nclass.get_mtype([elttype]) + var res = self.new_var(mtype) + res.is_exact = true self.require_declaration("NEW_{nclass.c_name}") - self.add("{nat} = NEW_{nclass.c_name}({array.length});") - for i in [0..array.length[ do - var r = self.autobox(array[i], self.object_type) - self.add("((struct instance_{nclass.c_instance_name}*){nat})->values[{i}] = (val*) {r};") - end - var length = self.int_instance(array.length) - self.send(self.get_property("with_native", arraytype), [res, nat, length]) - self.add("\}") + self.add("{res} = NEW_{nclass.c_name}({length});") return res end