X-Git-Url: http://nitlanguage.org diff --git a/src/separate_compiler.nit b/src/separate_compiler.nit index 280b094..612c22d 100644 --- a/src/separate_compiler.nit +++ b/src/separate_compiler.nit @@ -17,7 +17,8 @@ module separate_compiler import global_compiler # TODO better separation of concerns -intrude import coloring +import coloring + redef class ToolContext # --separate var opt_separate: OptionBool = new OptionBool("Use separate compilation", "--separate") @@ -25,11 +26,39 @@ redef class ToolContext # --no-inline-intern var opt_no_inline_intern: OptionBool = new OptionBool("Do not inline call to intern methods", "--no-inline-intern") + # --no-union-attribute + var opt_no_union_attribute: OptionBool = new OptionBool("Put primitive attibutes in a box instead of an union", "--no-union-attribute") + + # --no-shortcut-equate + var opt_no_shortcut_equate: OptionBool = new OptionBool("Always call == in a polymorphic way", "--no-shortcut-equal") + + # --inline-coloring-numbers + var opt_inline_coloring_numbers: OptionBool = new OptionBool("Inline colors and ids", "--inline-coloring-numbers") + + # --use-naive-coloring + var opt_bm_typing: OptionBool = new OptionBool("Colorize items incrementaly, used to simulate binary matrix typing", "--bm-typing") + + # --use-mod-perfect-hashing + var opt_phmod_typing: OptionBool = new OptionBool("Replace coloration by perfect hashing (with mod operator)", "--phmod-typing") + + # --use-and-perfect-hashing + var opt_phand_typing: OptionBool = new OptionBool("Replace coloration by perfect hashing (with and operator)", "--phand-typing") + + # --generic-resolution-tree + var opt_generic_tree: OptionBool = new OptionBool("Use tree representation for live generic types instead of flattened representation", "--generic-resolution-tree") + redef init do super self.option_context.add_option(self.opt_separate) self.option_context.add_option(self.opt_no_inline_intern) + self.option_context.add_option(self.opt_no_union_attribute) + self.option_context.add_option(self.opt_no_shortcut_equate) + self.option_context.add_option(self.opt_inline_coloring_numbers) + self.option_context.add_option(self.opt_bm_typing) + self.option_context.add_option(self.opt_phmod_typing) + self.option_context.add_option(self.opt_phand_typing) + self.option_context.add_option(self.opt_generic_tree) end end @@ -40,33 +69,7 @@ redef class ModelBuilder self.toolcontext.info("*** COMPILING TO C ***", 1) var compiler = new SeparateCompiler(mainmodule, runtime_type_analysis, self) - var v = compiler.new_visitor - compiler.header = v - v.add_decl("#include ") - v.add_decl("#include ") - v.add_decl("#include ") - v.add_decl("#include ") - v.add_decl("typedef void(*nitmethod_t)(void); /* general C type representing a Nit method. */") - v.add_decl("typedef void* nitattribute_t; /* general C type representing a Nit attribute. */") - - # Class abstract representation - v.add_decl("struct class \{ int box_kind; nitmethod_t vft[1]; \}; /* general C type representing a Nit class. */") - # Type abstract representation - v.add_decl("struct type \{ int id; int color; int livecolor; short int is_nullable; struct vts_table *vts_table; struct fts_table *fts_table; int table_size; int type_table[1]; \}; /* general C type representing a Nit type. */") - v.add_decl("struct fts_table \{ struct type *fts[1]; \}; /* fts list of a C type representation. */") - v.add_decl("struct vts_table \{ struct type *vts[1]; \}; /* vts list of a C type representation. */") - # Instance abstract representation - v.add_decl("typedef struct \{ struct type *type; struct class *class; nitattribute_t attrs[1]; \} val; /* general C type representing a Nit instance. */") - - compiler.compile_box_kinds - - # Declare global instances - v.add_decl("extern int glob_argc;") - v.add_decl("extern char **glob_argv;") - v.add_decl("extern val *glob_sys;") - - # The main function of the C - compiler.compile_main_function + compiler.compile_header # compile class structures for m in mainmodule.in_importation.greaters do @@ -75,24 +78,31 @@ redef class ModelBuilder end end + # The main function of the C + compiler.new_file + compiler.compile_main_function + # compile methods for m in mainmodule.in_importation.greaters do + compiler.new_file compiler.compile_module_to_c(m) end # compile live & cast type structures - var mtypes = compiler.do_global_type_coloring + compiler.new_file + var mtypes = compiler.do_type_coloring for t in mtypes do compiler.compile_type_to_c(t) end - # compile live generic types selection structures - for mclass in model.mclasses do - compiler.compile_live_gentype_to_c(mclass) + if self.toolcontext.opt_generic_tree.value then + # compile live generic types selection structures + for mclass in model.mclasses do + compiler.compile_live_gentype_to_c(mclass) + end end - # for the class_name and output_class_name methods - compiler.compile_class_names + compiler.display_stats write_and_make(compiler) end @@ -103,6 +113,7 @@ class SeparateCompiler super GlobalCompiler # TODO better separation of concerns private var undead_types: Set[MType] = new HashSet[MType] + private var partial_types: Set[MType] = new HashSet[MType] protected var typeids: HashMap[MType, Int] protected writable = new HashMap[MType, Int] private var type_colors: Map[MType, Int] = typeids @@ -111,45 +122,73 @@ class SeparateCompiler private var livetypes_colors: nullable Map[MType, Int] private var livetypes_tables: nullable Map[MClass, Array[nullable Object]] private var livetypes_tables_sizes: nullable Map[MClass, Array[Int]] + private var live_unanchored_types: Map[MClassDef, Set[MType]] = new HashMap[MClassDef, HashSet[MType]] - protected var class_colors: Map[MClass, Int] protected writable + private var unanchored_types_colors: nullable Map[MType, Int] + private var unanchored_types_tables: nullable Map[MClassType, Array[nullable MType]] + private var unanchored_types_masks: nullable Map[MClassType, Int] - protected var method_colors: Map[MMethod, Int] protected writable - protected var method_tables: Map[MClass, Array[nullable MMethodDef]] protected writable + protected var class_coloring: ClassColoring - protected var attr_colors: Map[MAttribute, Int] protected writable - protected var attr_tables: Map[MClass, Array[nullable MAttributeDef]] protected writable + protected var method_colors: Map[MMethod, Int] + protected var method_tables: Map[MClass, Array[nullable MMethodDef]] - private var vt_colors: Map[MVirtualTypeProp, Int] - private var vt_tables: Map[MClass, Array[nullable MVirtualTypeDef]] + protected var attr_colors: Map[MAttribute, Int] + protected var attr_tables: Map[MClass, Array[nullable MAttributeDef]] - private var ft_colors: Map[MParameterType, Int] - private var ft_tables: Map[MClass, Array[nullable MParameterType]] + protected var vt_colors: Map[MVirtualTypeProp, Int] + protected var vt_tables: Map[MClass, Array[nullable MVirtualTypeDef]] + protected var vt_masks: nullable Map[MClass, Int] + + private var ft_colors: nullable Map[MParameterType, Int] + private var ft_tables: nullable Map[MClass, Array[nullable MParameterType]] + private var ft_masks: nullable Map[MClass, Int] init(mainmodule: MModule, runtime_type_analysis: RapidTypeAnalysis, mmbuilder: ModelBuilder) do - # classes coloration - var class_coloring = new ClassColoring(mainmodule) - self.class_colors = class_coloring.colorize(mmbuilder.model.mclasses) + self.do_property_coloring + self.compile_box_kinds + end - # methods coloration - var method_coloring = new MethodColoring(class_coloring) - self.method_colors = method_coloring.colorize - self.method_tables = method_coloring.build_property_tables + 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 + self.header.add_decl("struct class \{ int box_kind; nitmethod_t vft[1]; \}; /* general C type representing a Nit class. */") - # attributes coloration - var attribute_coloring = new AttributeColoring(class_coloring) - self.attr_colors = attribute_coloring.colorize - self.attr_tables = attribute_coloring.build_property_tables + if modelbuilder.toolcontext.opt_generic_tree.value then + # With generic_tree, only ft and vt resolution is stored in the type + self.header.add_decl("struct type \{ int id; const char *name; int color; short int is_nullable; int livecolor; struct types *vts_table; struct types *fts_table; int table_size; int type_table[1]; \}; /* general C type representing a Nit type. */") + else + # With unanchored_table, all live type resolution are stored in a big table: unanchored_table + self.header.add_decl("struct type \{ int id; const char *name; int color; short int is_nullable; struct types *unanchored_table; int table_size; int type_table[1]; \}; /* general C type representing a Nit type. */") + end - # vt coloration - var vt_coloring = new VTColoring(class_coloring) - self.vt_colors = vt_coloring.colorize - self.vt_tables = vt_coloring.build_property_tables - - # fts coloration - var ft_coloring = new FTColoring(class_coloring) - self.ft_colors = ft_coloring.colorize - self.ft_tables = ft_coloring.build_ft_tables + if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then + self.header.add_decl("struct types \{ int mask; struct type *types[1]; \}; /* a list types (used for vts, fts and unanchored lists). */") + else + self.header.add_decl("struct types \{ struct type *types[1]; \}; /* a list types (used for vts, fts and unanchored lists). */") + end + + + self.header.add_decl("typedef struct \{ struct type *type; struct class *class; nitattribute_t attrs[1]; \} val; /* general C type representing a Nit instance. */") + end + + fun compile_header_attribute_structs + do + if modelbuilder.toolcontext.opt_no_union_attribute.value then + self.header.add_decl("typedef void* nitattribute_t; /* general C type representing a Nit attribute. */") + else + self.header.add_decl("typedef union \{") + self.header.add_decl("void* val;") + for c, v in self.box_kinds do + var t = c.mclass_type + self.header.add_decl("{t.ctype} {t.ctypename};") + end + self.header.add_decl("\} nitattribute_t; /* general C type representing a Nit attribute. */") + end + end + + redef fun compile_class_names do + abort # There is no class name compilation since the name is stored in the type structure end fun compile_box_kinds @@ -178,82 +217,253 @@ class SeparateCompiler end - protected fun compile_class_names do - - # Build type names table - var type_array = new Array[nullable MType] - for t, i in typeids do - if i >= type_array.length then - type_array[i] = null + fun compile_color_consts(colors: Map[Object, Int]) do + for m, c in colors do + if m isa MProperty then + if modelbuilder.toolcontext.opt_inline_coloring_numbers.value then + self.header.add_decl("#define {m.const_color} {c}") + else + self.header.add_decl("extern const int {m.const_color};") + self.header.add("const int {m.const_color} = {c};") + end + else if m isa MType then + if modelbuilder.toolcontext.opt_inline_coloring_numbers.value then + self.header.add_decl("#define {m.const_color} {c}") + else + self.header.add_decl("extern const int {m.const_color};") + self.header.add("const int {m.const_color} = {c};") + end end - type_array[i] = t end + end - var v = self.new_visitor - self.header.add_decl("extern const char const * class_names[];") - v.add("const char const * class_names[] = \{") - for t in type_array do - if t == null then - v.add("NULL,") - else - v.add("\"{t}\",") - end + # colorize classe properties + fun do_property_coloring do + + # classes coloration + self.class_coloring = new ClassColoring(mainmodule) + class_coloring.colorize(modelbuilder.model.mclasses) + + # methods coloration + var method_coloring = new MethodColoring(self.class_coloring) + self.method_colors = method_coloring.colorize + self.method_tables = method_coloring.build_property_tables + self.compile_color_consts(self.method_colors) + + # attributes coloration + var attribute_coloring = new AttributeColoring(self.class_coloring) + self.attr_colors = attribute_coloring.colorize + self.attr_tables = attribute_coloring.build_property_tables + self.compile_color_consts(self.attr_colors) + + if modelbuilder.toolcontext.opt_bm_typing.value then + self.class_coloring = new NaiveClassColoring(mainmodule) + self.class_coloring.colorize(modelbuilder.model.mclasses) end - v.add("\};") + + # vt coloration + if modelbuilder.toolcontext.opt_bm_typing.value then + var vt_coloring = new NaiveVTColoring(self.class_coloring) + self.vt_colors = vt_coloring.colorize + self.vt_tables = vt_coloring.build_property_tables + else if modelbuilder.toolcontext.opt_phmod_typing.value then + var vt_coloring = new VTModPerfectHashing(self.class_coloring) + self.vt_colors = vt_coloring.colorize + self.vt_masks = vt_coloring.compute_masks + self.vt_tables = vt_coloring.build_property_tables + else if modelbuilder.toolcontext.opt_phand_typing.value then + var vt_coloring = new VTAndPerfectHashing(self.class_coloring) + self.vt_colors = vt_coloring.colorize + self.vt_masks = vt_coloring.compute_masks + self.vt_tables = vt_coloring.build_property_tables + else + var vt_coloring = new VTColoring(self.class_coloring) + self.vt_colors = vt_coloring.colorize + self.vt_tables = vt_coloring.build_property_tables + end + self.compile_color_consts(self.vt_colors) end # colorize live types of the program - private fun do_global_type_coloring: Set[MType] do + private fun do_type_coloring: Set[MType] do 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 - self.undead_types.clear for mtype in mtypes 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.undead_types.add(ft) - end + retieve_live_partial_types(mtype) + end + mtypes.add_all(self.partial_types) + + # set type unique id + if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then + var sorted_mtypes = new OrderedSet[MType].from(mtypes) + sorted_mtypes.linearize(new ReverseTypeSorter(self.mainmodule)) + for mtype in sorted_mtypes do + self.typeids[mtype] = self.typeids.length + 1 end - var mclass_type: MClassType - if mtype isa MNullableType then - mclass_type = mtype.mtype.as(MClassType) + else + for mtype in mtypes do + self.typeids[mtype] = self.typeids.length + end + end + + if modelbuilder.toolcontext.opt_generic_tree.value then + # fts coloration for non-erased compilation + if modelbuilder.toolcontext.opt_bm_typing.value then + var ft_coloring = new NaiveFTColoring(self.class_coloring) + self.ft_colors = ft_coloring.colorize + self.ft_tables = ft_coloring.build_ft_tables + else if modelbuilder.toolcontext.opt_phmod_typing.value then + var ft_coloring = new FTModPerfectHashing(self.class_coloring) + self.ft_colors = ft_coloring.colorize + self.ft_masks = ft_coloring.compute_masks + self.ft_tables = ft_coloring.build_ft_tables + else if modelbuilder.toolcontext.opt_phand_typing.value then + var ft_coloring = new FTAndPerfectHashing(self.class_coloring) + self.ft_colors = ft_coloring.colorize + self.ft_masks = ft_coloring.compute_masks + self.ft_tables = ft_coloring.build_ft_tables + else + var ft_coloring = new FTColoring(self.class_coloring) + self.ft_colors = ft_coloring.colorize + self.ft_tables = ft_coloring.build_ft_tables + end + self.compile_color_consts(self.ft_colors.as(not null)) + + # colorize live entries + var entries_coloring + if modelbuilder.toolcontext.opt_bm_typing.value then + entries_coloring = new NaiveLiveEntryColoring else - mclass_type = mtype.as(MClassType) + entries_coloring = new LiveEntryColoring end - # add virtual types to mtypes - for vt in self.vt_tables[mclass_type.mclass] do - if vt != null then - var anchored = vt.bound.anchor_to(self.mainmodule, mclass_type) - self.undead_types.add(anchored) + self.livetypes_colors = entries_coloring.colorize(mtypes) + self.livetypes_tables = entries_coloring.build_livetype_tables(mtypes) + self.livetypes_tables_sizes = entries_coloring.livetypes_tables_sizes + else + # VT and FT are stored with other unresolved types in the big unanchored_tables + self.compile_unanchored_tables(mtypes) + end + + # colorize types + if modelbuilder.toolcontext.opt_bm_typing.value then + var type_coloring = new NaiveTypeColoring(self.mainmodule, mtypes) + self.type_colors = type_coloring.colorize(mtypes) + self.type_tables = type_coloring.build_type_tables(mtypes, type_colors) + else if modelbuilder.toolcontext.opt_phmod_typing.value then + var type_coloring = new TypeModPerfectHashing(self.mainmodule, mtypes) + self.type_colors = type_coloring.compute_masks(mtypes, typeids) + self.type_tables = type_coloring.hash_type_tables(mtypes, typeids, type_colors) + self.header.add_decl("#define HASH(mask, id) ((mask)%(id))") + else if modelbuilder.toolcontext.opt_phand_typing.value then + var type_coloring = new TypeAndPerfectHashing(self.mainmodule, mtypes) + self.type_colors = type_coloring.compute_masks(mtypes, typeids) + self.type_tables = type_coloring.hash_type_tables(mtypes, typeids, type_colors) + self.header.add_decl("#define HASH(mask, id) ((mask)&(id))") + else + var type_coloring = new TypeColoring(self.mainmodule, mtypes) + self.type_colors = type_coloring.colorize(mtypes) + self.type_tables = type_coloring.build_type_tables(mtypes, type_colors) + end + + + return mtypes + end + + protected fun compile_unanchored_tables(mtypes: Set[MType]) do + # Unanchored_tables is used to perform a type resolution at runtime in O(1) + + # During the visit of the body of classes, live_unanchored_types are collected + # and associated to + # Collect all live_unanchored_types (visited in the body of classes) + + # Determinate fo each livetype what are its possible requested anchored types + var mtype2unanchored = new HashMap[MClassType, Set[MType]] + for mtype in self.runtime_type_analysis.live_types do + var set = new HashSet[MType] + for cd in mtype.collect_mclassdefs(self.mainmodule) do + if self.live_unanchored_types.has_key(cd) then + set.add_all(self.live_unanchored_types[cd]) end end + mtype2unanchored[mtype] = set + end + + # Compute the table layout with the prefered method + if modelbuilder.toolcontext.opt_bm_typing.value then + var unanchored_type_coloring = new NaiveUnanchoredTypeColoring + self.unanchored_types_colors = unanchored_type_coloring.colorize(mtype2unanchored) + self.unanchored_types_tables = unanchored_type_coloring.build_tables(mtype2unanchored) + else if modelbuilder.toolcontext.opt_phmod_typing.value then + var unanchored_type_coloring = new UnanchoredTypeModPerfectHashing + self.unanchored_types_colors = unanchored_type_coloring.colorize(mtype2unanchored) + self.unanchored_types_masks = unanchored_type_coloring.compute_masks(mtype2unanchored) + self.unanchored_types_tables = unanchored_type_coloring.build_tables(mtype2unanchored) + else if modelbuilder.toolcontext.opt_phand_typing.value then + var unanchored_type_coloring = new UnanchoredTypeAndPerfectHashing + self.unanchored_types_colors = unanchored_type_coloring.colorize(mtype2unanchored) + self.unanchored_types_masks = unanchored_type_coloring.compute_masks(mtype2unanchored) + self.unanchored_types_tables = unanchored_type_coloring.build_tables(mtype2unanchored) + else + var unanchored_type_coloring = new UnanchoredTypeColoring + self.unanchored_types_colors = unanchored_type_coloring.colorize(mtype2unanchored) + self.unanchored_types_tables = unanchored_type_coloring.build_tables(mtype2unanchored) end - mtypes.add_all(self.undead_types) - # set type unique id - for mtype in mtypes do - self.typeids[mtype] = self.typeids.length + # Compile a C constant for each collected unanchored type. + # Either to a color, or to -1 if the unanchored type is dead (no live receiver can require it) + var all_unanchored = new HashSet[MType] + for t in self.live_unanchored_types.values do + all_unanchored.add_all(t) + end + var all_unanchored_types_colors = new HashMap[MType, Int] + for t in all_unanchored do + if unanchored_types_colors.has_key(t) then + all_unanchored_types_colors[t] = unanchored_types_colors[t] + else + all_unanchored_types_colors[t] = -1 + end end + self.compile_color_consts(all_unanchored_types_colors) - # colorize live entries - var entries_coloring = new LiveEntryColoring - self.livetypes_colors = entries_coloring.colorize(mtypes) - self.livetypes_tables = entries_coloring.build_livetype_tables(mtypes) - self.livetypes_tables_sizes = entries_coloring.livetypes_tables_sizes + #print "tables" + #for k, v in unanchored_types_tables.as(not null) do + # print "{k}: {v.join(", ")}" + #end + #print "" + end - # colorize types - var type_coloring = new TypeColoring(self.mainmodule, mtypes) - self.type_colors = type_coloring.colorize(mtypes) - self.type_tables = type_coloring.build_type_tables(mtypes, type_colors) + fun retieve_live_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) + retieve_live_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 - return mtypes + # add virtual types to mtypes + for vt in self.vt_tables[mclass_type.mclass] do + if vt != null then + var anchored = vt.bound.anchor_to(self.mainmodule, mclass_type) + self.partial_types.add(anchored) + end + end end # declare live generic types tables selection @@ -299,6 +509,8 @@ class SeparateCompiler # Separately compile all the method definitions of the module fun compile_module_to_c(mmodule: MModule) do + var old_module = self.mainmodule + self.mainmodule = mmodule for cd in mmodule.mclassdefs do for pd in cd.mpropdefs do if not pd isa MMethodDef then continue @@ -311,6 +523,7 @@ class SeparateCompiler end end end + self.mainmodule = old_module end # Globaly compile the type structure of a live type @@ -320,50 +533,53 @@ class SeparateCompiler var v = new SeparateCompilerVisitor(self) v.add_decl("/* runtime type {mtype} */") - var mclass_type: MClassType - if mtype isa MNullableType then - mclass_type = mtype.mtype.as(MClassType) - else - mclass_type = mtype.as(MClassType) - end - # extern const struct type_X self.header.add_decl("extern const struct type_{c_name} type_{c_name};") self.header.add_decl("struct type_{c_name} \{") self.header.add_decl("int id;") + self.header.add_decl("const char *name;") self.header.add_decl("int color;") - self.header.add_decl("int livecolor;") self.header.add_decl("short int is_nullable;") - self.header.add_decl("const struct vts_table_{c_name} *vts_table;") - self.header.add_decl("const struct fts_table_{c_name} *fts_table;") + if modelbuilder.toolcontext.opt_generic_tree.value then + self.header.add_decl("int livecolor;") + self.header.add_decl("const struct vts_table_{c_name} *vts_table;") + self.header.add_decl("const struct fts_table_{c_name} *fts_table;") + else + self.header.add_decl("const struct types *unanchored_table;") + end self.header.add_decl("int table_size;") self.header.add_decl("int type_table[{self.type_tables[mtype].length}];") self.header.add_decl("\};") - # extern const struct vts_table_X vts_table_X - self.header.add_decl("extern const struct vts_table_{c_name} vts_table_{c_name};") - self.header.add_decl("struct vts_table_{c_name} \{") - self.header.add_decl("struct type *vts[{self.vt_tables[mclass_type.mclass].length}];") - self.header.add_decl("\};") - - # extern const struct fst_table_X fst_table_X - self.header.add_decl("extern const struct fts_table_{c_name} fts_table_{c_name};") - self.header.add_decl("struct fts_table_{c_name} \{") - self.header.add_decl("struct type *fts[{self.ft_tables[mclass_type.mclass].length}];") - self.header.add_decl("\};") - # const struct type_X v.add_decl("const struct type_{c_name} type_{c_name} = \{") v.add_decl("{self.typeids[mtype]},") + v.add_decl("\"{mtype}\", /* class_name_string */") v.add_decl("{self.type_colors[mtype]},") - v.add_decl("{self.livetypes_colors[mtype]},") if mtype isa MNullableType then v.add_decl("1,") else v.add_decl("0,") end - v.add_decl("&vts_table_{c_name},") - v.add_decl("&fts_table_{c_name},") + if modelbuilder.toolcontext.opt_generic_tree.value then + v.add_decl("{self.livetypes_colors[mtype]},") + if compile_type_vts_table(mtype) then + v.add_decl("&vts_table_{c_name},") + else + v.add_decl("NULL,") + end + if compile_type_fts_table(mtype) then + v.add_decl("&fts_table_{c_name},") + else + v.add_decl("NULL,") + end + else + if compile_type_unanchored_table(mtype) then + v.add_decl("(struct types*) &unanchored_table_{c_name},") + else + v.add_decl("NULL,") + end + end v.add_decl("{self.type_tables[mtype].length},") v.add_decl("\{") for stype in self.type_tables[mtype] do @@ -375,15 +591,9 @@ class SeparateCompiler end v.add_decl("\},") v.add_decl("\};") - - build_fts_table(mtype, v) - build_vts_table(mtype, v) end - # const struct fst_table_X fst_table_X - private fun build_fts_table(mtype: MType, v: SeparateCompilerVisitor) do - v.add_decl("const struct fts_table_{mtype.c_name} fts_table_{mtype.c_name} = \{") - v.add_decl("\{") + protected fun compile_type_fts_table(mtype: MType): Bool do var mclass_type: MClassType if mtype isa MNullableType then @@ -391,7 +601,24 @@ class SeparateCompiler else mclass_type = mtype.as(MClassType) end + if self.ft_tables[mclass_type.mclass].is_empty then return false + + # extern const struct fst_table_X fst_table_X + self.header.add_decl("extern const struct fts_table_{mtype.c_name} fts_table_{mtype.c_name};") + self.header.add_decl("struct fts_table_{mtype.c_name} \{") + if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then + self.header.add_decl("int mask;") + end + self.header.add_decl("struct type *types[{self.ft_tables[mclass_type.mclass].length}];") + self.header.add_decl("\};") + # const struct fts_table_X fts_table_X + var v = new_visitor + v.add_decl("const struct fts_table_{mtype.c_name} fts_table_{mtype.c_name} = \{") + if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then + v.add_decl("{self.ft_masks[mclass_type.mclass]},") + end + v.add_decl("\{") for ft in self.ft_tables[mclass_type.mclass] do if ft == null then v.add_decl("NULL, /* empty */") @@ -411,12 +638,10 @@ class SeparateCompiler end v.add_decl("\},") v.add_decl("\};") + return true end - # const struct vts_table_X vts_table_X - private fun build_vts_table(mtype: MType, v: SeparateCompilerVisitor) do - v.add_decl("const struct vts_table_{mtype.c_name} vts_table_{mtype.c_name} = \{") - v.add_decl("\{") + protected fun compile_type_vts_table(mtype: MType): Bool do var mclass_type: MClassType if mtype isa MNullableType then @@ -424,6 +649,24 @@ class SeparateCompiler else mclass_type = mtype.as(MClassType) end + if self.vt_tables[mclass_type.mclass].is_empty then return false + + # extern const struct vts_table_X vts_table_X + self.header.add_decl("extern const struct vts_table_{mtype.c_name} vts_table_{mtype.c_name};") + self.header.add_decl("struct vts_table_{mtype.c_name} \{") + if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then + self.header.add_decl("int mask;") + end + self.header.add_decl("struct type *types[{self.vt_tables[mclass_type.mclass].length}];") + self.header.add_decl("\};") + + # const struct vts_table_X vts_table_X + var v = new_visitor + v.add_decl("const struct vts_table_{mtype.c_name} vts_table_{mtype.c_name} = \{") + if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then + v.add_decl("{vt_masks[mclass_type.mclass]},") + end + v.add_decl("\{") for vt in self.vt_tables[mclass_type.mclass] do if vt == null then @@ -462,6 +705,55 @@ class SeparateCompiler end v.add_decl("\},") v.add_decl("\};") + return true + end + + fun compile_type_unanchored_table(mtype: MType): Bool do + + var mclass_type: MClassType + if mtype isa MNullableType then + mclass_type = mtype.mtype.as(MClassType) + else + mclass_type = mtype.as(MClassType) + end + if not self.unanchored_types_tables.has_key(mclass_type) then return false + + # extern const struct unanchored_table_X unanchored_table_X + self.header.add_decl("extern const struct unanchored_table_{mtype.c_name} unanchored_table_{mtype.c_name};") + + self.header.add_decl("struct unanchored_table_{mtype.c_name} \{") + if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then + self.header.add_decl("int mask;") + end + self.header.add_decl("struct type *types[{self.unanchored_types_tables[mclass_type].length}];") + self.header.add_decl("\};") + + # const struct fts_table_X fts_table_X + var v = new_visitor + v.add_decl("const struct unanchored_table_{mtype.c_name} unanchored_table_{mtype.c_name} = \{") + if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then + v.add_decl("{self.unanchored_types_masks[mclass_type]},") + end + v.add_decl("\{") + for t in self.unanchored_types_tables[mclass_type] do + if t == null then + v.add_decl("NULL, /* empty */") + else + # The table stores the result of the type resolution + # Therefore, for a receiver `mclass_type`, and a unresolved type `t` + # the value stored is tv. + var tv = t.resolve_for(mclass_type, mclass_type, self.mainmodule, true) + # FIXME: What typeids means here? How can a tv not be live? + if self.typeids.has_key(tv) then + v.add_decl("(struct type*)&type_{tv.c_name}, /* {t}: {tv} */") + else + v.add_decl("NULL, /* empty ({t}: {tv} not a live type) */") + end + end + end + v.add_decl("\},") + v.add_decl("\};") + return true end # Globally compile the table of the class mclass @@ -474,7 +766,7 @@ class SeparateCompiler var vft = self.method_tables[mclass] var attrs = self.attr_tables[mclass] - var v = new SeparateCompilerVisitor(self) + var v = new_visitor v.add_decl("/* runtime class {c_name} */") var idnum = classids.length @@ -562,8 +854,18 @@ class SeparateCompiler else v.add("{res} = GC_MALLOC(sizeof(struct instance_{c_name}));") end - #v.add("{res} = calloc(sizeof(struct instance_{c_name}), 1);") v.add("{res}->type = type;") + if v.compiler.modelbuilder.toolcontext.opt_hardening.value then + v.add("if(type == NULL) \{") + v.add_abort("type null") + v.add("\}") + if not v.compiler.modelbuilder.toolcontext.opt_generic_tree.value then + v.add("if(type->unanchored_table == NULL) \{") + v.add("fprintf(stderr, \"Insantiation of a dead type: %s\\n\", type->name);") + v.add_abort("type dead") + v.add("\}") + end + end v.add("{res}->class = (struct class*) &class_{c_name};") self.generate_init_attr(v, res, mtype) @@ -800,6 +1102,17 @@ class SeparateCompilerVisitor end end + # Return a C expression returning the runtime type structure of the value + # The point of the method is to works also with primitives types. + fun type_info(value: RuntimeVariable): String + do + if value.mtype.ctype == "val*" then + return "{value}->type" + else + return "(&type_{value.mtype.c_name})" + end + end + redef fun send(mmethod, arguments) do if arguments.first.mcasttype.ctype != "val*" then @@ -824,7 +1137,7 @@ class SeparateCompilerVisitor var recv = arguments.first s.append("val*") ss.append("{recv}") - self.varargize(msignature, arguments) + self.varargize(mmethod.intro, mmethod.intro.msignature.as(not null), arguments) for i in [0..msignature.arity[ do var a = arguments[i+1] var t = msignature.mparameters[i].mtype @@ -865,11 +1178,26 @@ class SeparateCompilerVisitor end self.add("\} else \{") end + if not self.compiler.modelbuilder.toolcontext.opt_no_shortcut_equate.value and (mmethod.name == "==" or mmethod.name == "!=") then + assert res != null + # Recv is not null, thus is 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 + self.add("{res} = 1; /* arg is null and recv is not */") + end + if maybenull then + self.add("\}") + end + return res + end + end - var color = self.compiler.as(SeparateCompiler).method_colors[mmethod] var r if ret == null then r = "void" else r = ret.ctype - var call = "(({r} (*)({s}))({arguments.first}->class->vft[{color}]))({ss}) /* {mmethod} on {arguments.first.inspect}*/" + var call = "(({r} (*)({s}))({arguments.first}->class->vft[{mmethod.const_color}]))({ss}) /* {mmethod} on {arguments.first.inspect}*/" if res != null then self.add("{res} = {call};") @@ -927,11 +1255,50 @@ class SeparateCompilerVisitor return res end + redef fun vararg_instance(mpropdef, recv, varargs, elttype) + do + # A vararg must be stored into an new array + # The trick is that the dymaic type of the array may depends on the receiver + # of the method (ie recv) if the static type is unresolved + # This is more complex than usual because the unanchored type must not be resolved + # with the current receiver (ie self). + # Therefore to isolate the resolution from self, a local Frame 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]) + 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) + self.frame = old_frame + return res + end + redef fun isset_attribute(a, recv) do self.check_recv_notnull(recv) var res = self.new_var(bool_type) - self.add("{res} = {recv}->attrs[{self.compiler.as(SeparateCompiler).attr_colors[a]}] != NULL; /* {a} on {recv.inspect}*/") + + # What is the declared type of the attribute? + var mtype = a.intro.static_mtype.as(not null) + var intromclassdef = a.intro.mclassdef + mtype = mtype.resolve_for(intromclassdef.bound_mtype, intromclassdef.bound_mtype, intromclassdef.mmodule, true) + + if mtype isa MNullableType then + self.add("{res} = 1; /* easy isset: {a} on {recv.inspect} */") + return res + end + + if self.compiler.modelbuilder.toolcontext.opt_no_union_attribute.value then + self.add("{res} = {recv}->attrs[{a.const_color}] != NULL; /* {a} on {recv.inspect}*/") + else + + if mtype.ctype == "val*" then + self.add("{res} = {recv}->attrs[{a.const_color}].val != NULL; /* {a} on {recv.inspect} */") + else + self.add("{res} = 1; /* NOT YET IMPLEMENTED: isset of primitives: {a} on {recv.inspect} */") + end + end return res end @@ -944,22 +1311,37 @@ class SeparateCompilerVisitor var intromclassdef = a.intro.mclassdef ret = ret.resolve_for(intromclassdef.bound_mtype, intromclassdef.bound_mtype, intromclassdef.mmodule, true) - # Get the attribute or a box (ie. always a val*) - var cret = self.object_type.as_nullable - var res = self.new_var(cret) - res.mcasttype = ret - self.add("{res} = {recv}->attrs[{self.compiler.as(SeparateCompiler).attr_colors[a]}]; /* {a} on {recv.inspect} */") + if self.compiler.modelbuilder.toolcontext.opt_no_union_attribute.value then + # Get the attribute or a box (ie. always a val*) + var cret = self.object_type.as_nullable + var res = self.new_var(cret) + res.mcasttype = ret - # Check for Uninitialized attribute - if not ret isa MNullableType and not self.compiler.modelbuilder.toolcontext.opt_no_check_initialization.value then - self.add("if ({res} == NULL) \{") - self.add_abort("Uninitialized attribute {a.name}") - self.add("\}") - end + self.add("{res} = {recv}->attrs[{a.const_color}]; /* {a} on {recv.inspect} */") + + # Check for Uninitialized attribute + if not ret isa MNullableType and not self.compiler.modelbuilder.toolcontext.opt_no_check_initialization.value then + self.add("if ({res} == NULL) \{") + self.add_abort("Uninitialized attribute {a.name}") + self.add("\}") + end - # Return the attribute or its unboxed version - # Note: it is mandatory since we reuse the box on write, we do not whant that the box escapes - return self.autobox(res, ret) + # Return the attribute or its unboxed version + # Note: it is mandatory since we reuse the box on write, we do not whant that the box escapes + return self.autobox(res, ret) + else + var res = self.new_var(ret) + self.add("{res} = {recv}->attrs[{a.const_color}].{ret.ctypename}; /* {a} on {recv.inspect} */") + + # Check for Uninitialized attribute + if ret.ctype == "val*" and not ret isa MNullableType and not self.compiler.modelbuilder.toolcontext.opt_no_check_initialization.value then + self.add("if ({res} == NULL) \{") + self.add_abort("Uninitialized attribute {a.name}") + self.add("\}") + end + + return res + end end redef fun write_attribute(a, recv, value) @@ -973,20 +1355,25 @@ class SeparateCompilerVisitor # Adapt the value to the declared type value = self.autobox(value, mtype) - var attr = "{recv}->attrs[{self.compiler.as(SeparateCompiler).attr_colors[a]}]" - if mtype.ctype != "val*" then - assert mtype isa MClassType - # 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("\} else \{") - value = self.autobox(value, self.object_type.as_nullable) - self.add("{attr} = {value}; /* {a} on {recv.inspect} */") - self.add("\}") + + if self.compiler.modelbuilder.toolcontext.opt_no_union_attribute.value then + var attr = "{recv}->attrs[{a.const_color}]" + if mtype.ctype != "val*" then + assert mtype isa MClassType + # 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("\} else \{") + value = self.autobox(value, self.object_type.as_nullable) + self.add("{attr} = {value}; /* {a} on {recv.inspect} */") + self.add("\}") + else + # The attribute is not primitive, thus store it direclty + self.add("{attr} = {value}; /* {a} on {recv.inspect} */") + end else - # The attribute is not primitive, thus store it direclty - self.add("{attr} = {value}; /* {a} on {recv.inspect} */") + self.add("{recv}->attrs[{a.const_color}].{mtype.ctypename} = {value}; /* {a} on {recv.inspect} */") end end @@ -1004,12 +1391,20 @@ class SeparateCompilerVisitor ntype = ntype.mtype end + var recv = self.frame.arguments.first + var recv_type_info = self.type_info(recv) if ntype isa MParameterType then - var ftcolor = compiler.ft_colors[ntype] - buffer.append("[self->type->fts_table->fts[{ftcolor}]->livecolor]") + if compiler.modelbuilder.toolcontext.opt_phmod_typing.value or compiler.modelbuilder.toolcontext.opt_phand_typing.value then + buffer.append("[{recv_type_info}->fts_table->types[HASH({recv_type_info}->fts_table->mask, {ntype.const_color})]->livecolor]") + else + buffer.append("[{recv_type_info}->fts_table->types[{ntype.const_color}]->livecolor]") + end else if ntype isa MVirtualType then - var vtcolor = compiler.vt_colors[ntype.mproperty.as(MVirtualTypeProp)] - buffer.append("[self->type->vts_table->vts[{vtcolor}]->livecolor]") + if compiler.modelbuilder.toolcontext.opt_phmod_typing.value or compiler.modelbuilder.toolcontext.opt_phand_typing.value then + buffer.append("[{recv_type_info}->vts_table->types[HASH({recv_type_info}->vts_table->mask, {ntype.mproperty.const_color})]->livecolor]") + else + buffer.append("[{recv_type_info}->vts_table->types[{ntype.mproperty.const_color}]->livecolor]") + end else if ntype isa MGenericType and ntype.need_anchor then var bbuff = new Buffer retrieve_anchored_livetype(ntype, bbuff) @@ -1027,10 +1422,21 @@ class SeparateCompilerVisitor do var compiler = self.compiler.as(SeparateCompiler) if mtype isa MGenericType and mtype.need_anchor then - var buff = new Buffer - retrieve_anchored_livetype(mtype, buff) - mtype = self.anchor(mtype).as(MClassType) - return self.new_expr("NEW_{mtype.mclass.c_name}((struct type *) livetypes_{mtype.mclass.c_name}{buff.to_s})", mtype) + if compiler.modelbuilder.toolcontext.opt_generic_tree.value then + var buff = new Buffer + retrieve_anchored_livetype(mtype, buff) + mtype = self.anchor(mtype).as(MClassType) + return self.new_expr("NEW_{mtype.mclass.c_name}((struct type *) livetypes_{mtype.mclass.c_name}{buff.to_s})", mtype) + else + link_unanchored_type(self.frame.mpropdef.mclassdef, mtype) + var recv = self.frame.arguments.first + var recv_type_info = self.type_info(recv) + if compiler.modelbuilder.toolcontext.opt_phmod_typing.value or compiler.modelbuilder.toolcontext.opt_phand_typing.value then + return self.new_expr("NEW_{mtype.mclass.c_name}((struct type *) {recv_type_info}->unanchored_table->types[HASH({recv_type_info}->unanchored_table->mask, {mtype.const_color})])", mtype) + else + return self.new_expr("NEW_{mtype.mclass.c_name}((struct type *) {recv_type_info}->unanchored_table->types[{mtype.const_color}])", mtype) + end + end end compiler.undead_types.add(mtype) return self.new_expr("NEW_{mtype.mclass.c_name}((struct type *) &type_{mtype.c_name})", mtype) @@ -1043,12 +1449,13 @@ class SeparateCompilerVisitor end - redef fun type_test(value, mtype) + redef fun type_test(value, mtype, tag) do + self.add("/* {value.inspect} isa {mtype} */") var compiler = self.compiler.as(SeparateCompiler) var recv = self.frame.arguments.first - var recv_boxed = self.autobox(recv, self.object_type) + var recv_type_info = self.type_info(recv) var res = self.new_var(bool_type) @@ -1056,40 +1463,75 @@ class SeparateCompilerVisitor self.add_decl("int {cltype};") var idtype = self.get_name("idtype") self.add_decl("int {idtype};") - var is_nullable = self.get_name("is_nullable") self.add_decl("short int {is_nullable};") - var boxed = self.autobox(value, self.object_type) - var ntype = mtype if ntype isa MNullableType then ntype = ntype.mtype end - if ntype isa MParameterType then - var ftcolor = compiler.ft_colors[ntype] - self.add("{cltype} = {recv_boxed}->type->fts_table->fts[{ftcolor}]->color;") - self.add("{idtype} = {recv_boxed}->type->fts_table->fts[{ftcolor}]->id;") - self.add("{is_nullable} = {recv_boxed}->type->fts_table->fts[{ftcolor}]->is_nullable;") - else if ntype isa MGenericType and ntype.need_anchor then - var buff = new Buffer - retrieve_anchored_livetype(ntype, buff) - self.add("{cltype} = livetypes_{ntype.mclass.c_name}{buff.to_s}->color;") - self.add("{idtype} = livetypes_{ntype.mclass.c_name}{buff.to_s}->id;") - self.add("{is_nullable} = livetypes_{ntype.mclass.c_name}{buff.to_s}->is_nullable;") + if value.mcasttype.is_subtype(self.frame.mpropdef.mclassdef.mmodule, self.frame.mpropdef.mclassdef.bound_mtype, mtype) then + self.add("{res} = 1; /* easy {value.inspect} isa {mtype}*/") + if compiler.modelbuilder.toolcontext.opt_typing_test_metrics.value then + self.compiler.count_type_test_skipped[tag] += 1 + self.add("count_type_test_skipped_{tag}++;") + end + return res + end + + if ntype.need_anchor then + var type_struct = self.get_name("type_struct") + self.add_decl("struct type* {type_struct};") + + # For unresolved types, there is two implementations + if compiler.modelbuilder.toolcontext.opt_generic_tree.value then + # Either with the generic_tree and the construction of a type + if ntype isa MParameterType then + if compiler.modelbuilder.toolcontext.opt_phmod_typing.value or compiler.modelbuilder.toolcontext.opt_phand_typing.value then + self.add("{type_struct} = {recv_type_info}->fts_table->types[HASH({recv_type_info}->fts_table->mask, {ntype.const_color})];") + else + self.add("{type_struct} = {recv_type_info}->fts_table->types[{ntype.const_color}];") + end + else if ntype isa MVirtualType then + var vtcolor = ntype.mproperty.const_color + if compiler.modelbuilder.toolcontext.opt_phmod_typing.value or compiler.modelbuilder.toolcontext.opt_phand_typing.value then + self.add("{type_struct} = {recv_type_info}->vts_table->types[HASH({recv_type_info}->vts_table->mask, {vtcolor})];") + else + self.add("{type_struct} = {recv_type_info}->vts_table->types[{vtcolor}];") + end + else if ntype isa MGenericType then + var buff = new Buffer + retrieve_anchored_livetype(ntype, buff) + self.add("{type_struct} = (struct type*)livetypes_{ntype.mclass.c_name}{buff.to_s};") + end + else + # Either with unanchored_table with a direct resolution + link_unanchored_type(self.frame.mpropdef.mclassdef, ntype) + if compiler.modelbuilder.toolcontext.opt_phmod_typing.value or compiler.modelbuilder.toolcontext.opt_phand_typing.value then + self.add("{type_struct} = {recv_type_info}->unanchored_table->types[HASH({recv_type_info}->unanchored_table->mask, {ntype.const_color})];") + else + self.add("{type_struct} = {recv_type_info}->unanchored_table->types[{ntype.const_color}];") + end + if compiler.modelbuilder.toolcontext.opt_typing_test_metrics.value then + self.compiler.count_type_test_unresolved[tag] += 1 + self.add("count_type_test_unresolved_{tag}++;") + end + end + self.add("{cltype} = {type_struct}->color;") + self.add("{idtype} = {type_struct}->id;") + self.add("{is_nullable} = {type_struct}->is_nullable;") else if ntype isa MClassType then compiler.undead_types.add(mtype) self.add("{cltype} = type_{mtype.c_name}.color;") self.add("{idtype} = type_{mtype.c_name}.id;") self.add("{is_nullable} = type_{mtype.c_name}.is_nullable;") - else if ntype isa MVirtualType then - var vtcolor = compiler.vt_colors[ntype.mproperty.as(MVirtualTypeProp)] - self.add("{cltype} = {recv_boxed}->type->vts_table->vts[{vtcolor}]->color;") - self.add("{idtype} = {recv_boxed}->type->vts_table->vts[{vtcolor}]->id;") - self.add("{is_nullable} = {recv_boxed}->type->vts_table->vts[{vtcolor}]->is_nullable;") + if compiler.modelbuilder.toolcontext.opt_typing_test_metrics.value then + self.compiler.count_type_test_resolved[tag] += 1 + self.add("count_type_test_resolved_{tag}++;") + end else - self.add("printf(\"NOT YET IMPLEMENTED: type_test(%s, {mtype}).\\n\", \"{boxed.inspect}\"); exit(1);") + self.add("printf(\"NOT YET IMPLEMENTED: type_test(%s, {mtype}).\\n\", \"{value.inspect}\"); exit(1);") end if mtype isa MNullableType then @@ -1097,15 +1539,23 @@ class SeparateCompilerVisitor end # check color is in table - self.add("if({boxed} == NULL) \{") - self.add("{res} = {is_nullable};") - self.add("\} else \{") - self.add("if({cltype} >= {boxed}->type->table_size) \{") + if self.maybe_null(value) then + self.add("if({value} == NULL) \{") + self.add("{res} = {is_nullable};") + self.add("\} else \{") + end + var value_type_info = self.type_info(value) + if compiler.modelbuilder.toolcontext.opt_phmod_typing.value or compiler.modelbuilder.toolcontext.opt_phand_typing.value then + self.add("{cltype} = HASH({value_type_info}->color, {idtype});") + end + self.add("if({cltype} >= {value_type_info}->table_size) \{") self.add("{res} = 0;") self.add("\} else \{") - self.add("{res} = {boxed}->type->type_table[{cltype}] == {idtype};") - self.add("\}") + self.add("{res} = {value_type_info}->type_table[{cltype}] == {idtype};") self.add("\}") + if self.maybe_null(value) then + self.add("\}") + end return res end @@ -1137,8 +1587,12 @@ class SeparateCompilerVisitor redef fun class_name_string(value) do var res = self.get_name("var_class_name") - self.add_decl("const char *{res};") - self.add("{res} = class_names[{value}->type->id];") + self.add_decl("const char* {res};") + if value.mtype.ctype == "val*" then + self.add "{res} = {value} == NULL ? \"null\" : {value}->type->name;" + else + self.add "{res} = type_{value.mtype.c_name}.name;" + end return res end @@ -1248,27 +1702,49 @@ class SeparateCompilerVisitor redef fun array_instance(array, elttype) do - var compiler = self.compiler.as(SeparateCompiler) var nclass = self.get_class("NativeArray") - elttype = self.anchor(elttype) - var arraytype = self.get_class("Array").get_mtype([elttype]) + var arrayclass = self.get_class("Array") + var arraytype = arrayclass.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 - compiler.undead_types.add(nat.mtype.as(MClassType)) - self.add("{nat} = NEW_{nclass.c_name}({array.length}, (struct type *) &type_{nat.mtype.c_name});") + var length = self.int_instance(array.length) + var nat = native_array_instance(elttype, length) for i in [0..array.length[ do var r = self.autobox(array[i], self.object_type) self.add("((struct instance_{nclass.c_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.send(self.get_property("with_native", arrayclass.intro.bound_mtype), [res, nat, length]) self.check_init_instance(res, arraytype) self.add("\}") return res end + fun native_array_instance(elttype: MType, length: RuntimeVariable): RuntimeVariable + do + var mtype = self.get_class("NativeArray").get_mtype([elttype]) + assert mtype isa MGenericType + var compiler = self.compiler.as(SeparateCompiler) + if mtype.need_anchor then + if compiler.modelbuilder.toolcontext.opt_generic_tree.value then + var buff = new Buffer + retrieve_anchored_livetype(mtype, buff) + mtype = self.anchor(mtype).as(MClassType) + return self.new_expr("NEW_{mtype.mclass.c_name}({length}, (struct type *) livetypes_{mtype.mclass.c_name}{buff.to_s})", mtype) + else + link_unanchored_type(self.frame.mpropdef.mclassdef, mtype) + var recv = self.frame.arguments.first + var recv_type_info = self.type_info(recv) + if compiler.modelbuilder.toolcontext.opt_phmod_typing.value or compiler.modelbuilder.toolcontext.opt_phand_typing.value then + return self.new_expr("NEW_{mtype.mclass.c_name}({length}, (struct type *) {recv_type_info}->unanchored_table->types[HASH({recv_type_info}->unanchored_table->mask, {mtype.const_color})])", mtype) + else + return self.new_expr("NEW_{mtype.mclass.c_name}({length}, (struct type *) {recv_type_info}->unanchored_table->types[{mtype.const_color}])", mtype) + end + end + end + compiler.undead_types.add(mtype) + return self.new_expr("NEW_{mtype.mclass.c_name}({length}, (struct type *) &type_{mtype.c_name})", mtype) + end + redef fun native_array_def(pname, ret_type, arguments) do var elttype = arguments.first.mtype @@ -1289,13 +1765,19 @@ class SeparateCompilerVisitor redef fun calloc_array(ret_type, arguments) do - var ret = ret_type.as(MGenericType) - var compiler = self.compiler.as(SeparateCompiler) - compiler.undead_types.add(ret) var mclass = self.get_class("ArrayCapable") var ft = mclass.mclass_type.arguments.first.as(MParameterType) - var color = compiler.ft_colors[ft] - self.ret(self.new_expr("NEW_{ret.mclass.c_name}({arguments[1]}, (struct type*) livetypes_array__NativeArray[self->type->fts_table->fts[{color}]->livecolor])", ret_type)) + var res = self.native_array_instance(ft, arguments[1]) + self.ret(res) + end + + fun link_unanchored_type(mclassdef: MClassDef, mtype: MType) do + assert mtype.need_anchor + var compiler = self.compiler.as(SeparateCompiler) + if not compiler.live_unanchored_types.has_key(self.frame.mpropdef.mclassdef) then + compiler.live_unanchored_types[self.frame.mpropdef.mclassdef] = new HashSet[MType] + end + compiler.live_unanchored_types[self.frame.mpropdef.mclassdef].add(mtype) end end @@ -1310,3 +1792,53 @@ redef class MClass end private var c_name_cache: nullable String end + +redef class MType + fun const_color: String do return "COLOR_{c_name}" +end + +redef class MParameterType + redef fun c_name + do + var res = self.c_name_cache + if res != null then return res + res = "{self.mclass.c_name}_FT{self.rank}" + self.c_name_cache = res + return res + end +end + +redef class MVirtualType + redef fun c_name + do + var res = self.c_name_cache + if res != null then return res + res = "{self.mproperty.intro.mclassdef.mclass.c_name}_VT{self.mproperty.name}" + 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 + +redef class MProperty + fun c_name: String do + var res = self.c_name_cache + if res != null then return res + res = "{self.intro.c_name}" + self.c_name_cache = res + return res + end + private var c_name_cache: nullable String + + fun const_color: String do return "COLOR_{c_name}" +end