module separate_compiler
import abstract_compiler
-intrude import coloring
+import layout_builders
import rapid_type_analysis
# Add separate compiler specific options
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_typing_table_metrics: OptionBool = new OptionBool("Enable static size measuring of tables used for typing and resolution", "--typing-table-metrics")
+ # --tables-metrics
+ var opt_tables_metrics: OptionBool = new OptionBool("Enable static size measuring of tables used for vft, typing and resolution", "--tables-metrics")
redef init
do
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_typing_table_metrics)
+ self.option_context.add_option(self.opt_tables_metrics)
end
end
class SeparateCompiler
super AbstractCompiler
- # Cache for classid
- protected var classids: HashMap[MClassType, String] = new HashMap[MClassType, String]
-
# The result of the RTA (used to know live types and methods)
var runtime_type_analysis: 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_builder: TypeLayoutBuilder
- private var type_layout: nullable TypeLayout
- private var type_tables: nullable Map[MType, Array[nullable MType]] = null
-
- private var live_unanchored_types: Map[MClassDef, Set[MType]] = new HashMap[MClassDef, HashSet[MType]]
-
- 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 class_coloring: ClassColoring
-
- protected var method_colors: Map[MMethod, Int]
- protected var method_tables: Map[MClass, Array[nullable MMethodDef]]
-
- protected var attr_colors: Map[MAttribute, Int]
- protected var attr_tables: Map[MClass, Array[nullable MAttributeDef]]
-
- 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]
+ private var type_layout: nullable Layout[MType]
+ private var resolution_layout: nullable Layout[MType]
+ protected var method_layout: nullable Layout[MMethod]
+ protected var attr_layout: nullable Layout[MAttribute]
init(mainmodule: MModule, mmbuilder: ModelBuilder, runtime_type_analysis: RapidTypeAnalysis) do
- super
+ super(mainmodule, mmbuilder)
self.header = new_visitor
- self.init_layout_builders
self.runtime_type_analysis = runtime_type_analysis
self.do_property_coloring
self.compile_box_kinds
end
- protected fun init_layout_builders do
- # Typing Layout
- if modelbuilder.toolcontext.opt_bm_typing.value then
- self.type_layout_builder = new BMTypeLayoutBuilder(self.mainmodule)
- else if modelbuilder.toolcontext.opt_phmod_typing.value then
- self.type_layout_builder = new PHTypeLayoutBuilder(self.mainmodule, new PHModOperator)
- self.header.add_decl("#define HASH(mask, id) ((mask)%(id))")
- else if modelbuilder.toolcontext.opt_phand_typing.value then
- self.type_layout_builder = new PHTypeLayoutBuilder(self.mainmodule, new PHAndOperator)
- self.header.add_decl("#define HASH(mask, id) ((mask)&(id))")
- else
- self.type_layout_builder = new CLTypeLayoutBuilder(self.mainmodule)
- 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
self.header.add_decl("struct class \{ int box_kind; nitmethod_t vft[1]; \}; /* general C type representing a Nit class. */")
- # 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. */")
+ # With resolution_table_table, all live type resolution are stored in a big table: resolution_table
+ self.header.add_decl("struct type \{ int id; const char *name; int color; short int is_nullable; struct types *resolution_table; int table_size; int type_table[1]; \}; /* general C type representing a Nit type. */")
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). */")
+ self.header.add_decl("struct types \{ int mask; struct type *types[1]; \}; /* a list types (used for vts, fts and unresolved lists). */")
else
- self.header.add_decl("struct types \{ struct type *types[1]; \}; /* a list types (used for vts, fts and unanchored lists). */")
+ self.header.add_decl("struct types \{ struct type *types[1]; \}; /* a list types (used for vts, fts and unresolved lists). */")
+ end
+
+ if modelbuilder.toolcontext.opt_phmod_typing.value then
+ self.header.add_decl("#define HASH(mask, id) ((mask)%(id))")
+ else if modelbuilder.toolcontext.opt_phand_typing.value then
+ self.header.add_decl("#define HASH(mask, id) ((mask)&(id))")
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. */")
fun compile_color_consts(colors: Map[Object, Int]) do
for m, c in colors do
+ if color_consts_done.has(m) then continue
if m isa MProperty then
if modelbuilder.toolcontext.opt_inline_coloring_numbers.value then
self.header.add_decl("#define {m.const_color} {c}")
self.header.add("const int {m.const_color} = {c};")
end
end
+ color_consts_done.add(m)
end
end
+ private var color_consts_done = new HashSet[Object]
+
# colorize classe properties
fun do_property_coloring do
-
- # classes coloration
var mclasses = new HashSet[MClass].from(modelbuilder.model.mclasses)
- self.class_coloring = new ClassColoring(mainmodule)
- class_coloring.colorize(mclasses)
+
+ # Layouts
+ var method_layout_builder: PropertyLayoutBuilder[MMethod]
+ var attribute_layout_builder: PropertyLayoutBuilder[MAttribute]
+ if modelbuilder.toolcontext.opt_bm_typing.value then
+ method_layout_builder = new MMethodBMizer(self.mainmodule)
+ attribute_layout_builder = new MAttributeBMizer(self.mainmodule)
+ else
+ method_layout_builder = new MMethodColorer(self.mainmodule)
+ attribute_layout_builder = new MAttributeColorer(self.mainmodule)
+ end
# 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)
+ var method_layout = method_layout_builder.build_layout(mclasses)
+ self.method_tables = build_method_tables(mclasses, method_layout)
+ self.compile_color_consts(method_layout.pos)
+ self.method_layout = method_layout
# 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)
+ var attr_layout = attribute_layout_builder.build_layout(mclasses)
+ self.attr_tables = build_attr_tables(mclasses, attr_layout)
+ self.compile_color_consts(attr_layout.pos)
+ self.attr_layout = attr_layout
+ end
- if modelbuilder.toolcontext.opt_bm_typing.value then
- self.class_coloring = new NaiveClassColoring(mainmodule)
- self.class_coloring.colorize(mclasses)
+ fun build_method_tables(mclasses: Set[MClass], layout: Layout[MProperty]): 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]
+ # first, fill table from parents by reverse linearization order
+ var parents = self.mainmodule.super_mclasses(mclass)
+ var lin = self.mainmodule.reverse_linearize_mclasses(parents)
+ for parent in lin do
+ for mproperty in self.mainmodule.properties(parent) do
+ if not mproperty isa MMethod then continue
+ var color = layout.pos[mproperty]
+ if table.length <= color then
+ for i in [table.length .. color[ do
+ table[i] = null
+ end
+ end
+ for mpropdef in mproperty.mpropdefs do
+ if mpropdef.mclassdef.mclass == parent then
+ table[color] = mpropdef
+ end
+ end
+ end
+ end
+
+ # then override with local properties
+ for mproperty in self.mainmodule.properties(mclass) do
+ if not mproperty isa MMethod then continue
+ var color = layout.pos[mproperty]
+ if table.length <= color then
+ for i in [table.length .. color[ do
+ table[i] = null
+ end
+ end
+ for mpropdef in mproperty.mpropdefs do
+ if mpropdef.mclassdef.mclass == mclass then
+ table[color] = mpropdef
+ end
+ end
+ end
+ tables[mclass] = table
end
+ return tables
+ end
- # 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
+ fun build_attr_tables(mclasses: Set[MClass], layout: Layout[MProperty]): 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]
+ # first, fill table from parents by reverse linearization order
+ var parents = self.mainmodule.super_mclasses(mclass)
+ var lin = self.mainmodule.reverse_linearize_mclasses(parents)
+ for parent in lin do
+ for mproperty in self.mainmodule.properties(parent) do
+ if not mproperty isa MAttribute then continue
+ var color = layout.pos[mproperty]
+ if table.length <= color then
+ for i in [table.length .. color[ do
+ table[i] = null
+ end
+ end
+ for mpropdef in mproperty.mpropdefs do
+ if mpropdef.mclassdef.mclass == parent then
+ table[color] = mpropdef
+ end
+ end
+ end
+ end
+
+ # then override with local properties
+ for mproperty in self.mainmodule.properties(mclass) do
+ if not mproperty isa MAttribute then continue
+ var color = layout.pos[mproperty]
+ if table.length <= color then
+ for i in [table.length .. color[ do
+ table[i] = null
+ end
+ end
+ for mpropdef in mproperty.mpropdefs do
+ if mpropdef.mclassdef.mclass == mclass then
+ table[color] = mpropdef
+ end
+ end
+ end
+ tables[mclass] = table
end
- self.compile_color_consts(self.vt_colors)
+ return tables
end
# colorize live types of the program
end
mtypes.add_all(self.partial_types)
- # VT and FT are stored with other unresolved types in the big unanchored_tables
- self.compile_unanchored_tables(mtypes)
-
- # colorize types
- var type_layout = self.type_layout_builder.build_layout(mtypes)
- if type_layout isa PHTypeLayout then
- self.type_tables = self.hash_type_tables(mtypes, type_layout.hashes)
+ # Typing Layout
+ var layout_builder: TypingLayoutBuilder[MType]
+ if modelbuilder.toolcontext.opt_bm_typing.value then
+ layout_builder = new MTypeBMizer(self.mainmodule)
+ else if modelbuilder.toolcontext.opt_phmod_typing.value then
+ layout_builder = new MTypeHasher(new PHModOperator, self.mainmodule)
+ else if modelbuilder.toolcontext.opt_phand_typing.value then
+ layout_builder = new MTypeHasher(new PHAndOperator, self.mainmodule)
else
- self.type_tables = self.build_type_tables(mtypes, type_layout.pos)
+ layout_builder = new MTypeColorer(self.mainmodule)
end
- self.type_layout = type_layout
+
+ # colorize types
+ self.type_layout = layout_builder.build_layout(mtypes)
+ self.type_tables = self.build_type_tables(mtypes)
+
+ # VT and FT are stored with other unresolved types in the big resolution_tables
+ self.compile_resolution_tables(mtypes)
+
return mtypes
end
# Build type tables
- fun build_type_tables(mtypes: Set[MType], colors: Map[MType, Int]): Map[MType, Array[nullable MType]] do
+ fun build_type_tables(mtypes: Set[MType]): Map[MType, Array[nullable MType]] do
var tables = new HashMap[MType, Array[nullable MType]]
-
+ var layout = self.type_layout
for mtype in mtypes do
var table = new Array[nullable MType]
var supers = new HashSet[MType]
supers.add_all(self.mainmodule.super_mtypes(mtype, mtypes))
supers.add(mtype)
for sup in supers do
- var color = colors[sup]
- if table.length <= color then
- for i in [table.length .. color[ do
- table[i] = null
- end
+ var color: Int
+ if layout isa PHLayout[MType, MType] then
+ color = layout.hashes[mtype][sup]
+ else
+ color = layout.pos[sup]
end
- table[color] = sup
- end
- tables[mtype] = table
- end
- return tables
- end
-
- # Build type tables
- fun hash_type_tables(mtypes: Set[MType], hashes: Map[MType, Map[MType, Int]]): Map[MType, Array[nullable MType]] do
- var tables = new HashMap[MType, Array[nullable MType]]
-
- for mtype in mtypes do
- var table = new Array[nullable MType]
- var supers = hashes[mtype]
- for sup, color in supers do
if table.length <= color then
for i in [table.length .. color[ do
table[i] = null
return tables
end
- protected fun compile_unanchored_tables(mtypes: Set[MType]) do
- # Unanchored_tables is used to perform a type resolution at runtime in O(1)
+ protected fun compile_resolution_tables(mtypes: Set[MType]) do
+ # resolution_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
+ # During the visit of the body of classes, live_unresolved_types are collected
# and associated to
- # Collect all live_unanchored_types (visited in the body of classes)
+ # Collect all live_unresolved_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]]
+ var mtype2unresolved = 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])
+ if self.live_unresolved_types.has_key(cd) then
+ set.add_all(self.live_unresolved_types[cd])
end
end
- mtype2unanchored[mtype] = set
+ mtype2unresolved[mtype] = set
end
# Compute the table layout with the prefered method
+ var resolution_builder: ResolutionLayoutBuilder
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)
+ resolution_builder = new ResolutionBMizer
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)
+ resolution_builder = new ResolutionHasher(new PHModOperator)
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)
+ resolution_builder = new ResolutionHasher(new PHAndOperator)
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)
+ resolution_builder = new ResolutionColorer
end
+ self.resolution_layout = resolution_builder.build_layout(mtype2unresolved)
+ self.resolution_tables = self.build_resolution_tables(mtype2unresolved)
- # 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)
+ # Compile a C constant for each collected unresolved type.
+ # Either to a color, or to -1 if the unresolved type is dead (no live receiver can require it)
+ var all_unresolved = new HashSet[MType]
+ for t in self.live_unresolved_types.values do
+ all_unresolved.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]
+ var all_unresolved_types_colors = new HashMap[MType, Int]
+ for t in all_unresolved do
+ if self.resolution_layout.pos.has_key(t) then
+ all_unresolved_types_colors[t] = self.resolution_layout.pos[t]
else
- all_unanchored_types_colors[t] = -1
+ all_unresolved_types_colors[t] = -1
end
end
- self.compile_color_consts(all_unanchored_types_colors)
+ self.compile_color_consts(all_unresolved_types_colors)
#print "tables"
- #for k, v in unanchored_types_tables.as(not null) do
+ #for k, v in unresolved_types_tables.as(not null) do
# print "{k}: {v.join(", ")}"
#end
#print ""
end
+ fun build_resolution_tables(elements: Map[MClassType, Set[MType]]): Map[MClassType, Array[nullable MType]] do
+ var tables = new HashMap[MClassType, Array[nullable MType]]
+ var layout = self.resolution_layout
+ for mclasstype, mtypes in elements do
+ var table = new Array[nullable MType]
+ for mtype in mtypes do
+ var color: Int
+ if layout isa PHLayout[MClassType, MType] then
+ color = layout.hashes[mclasstype][mtype]
+ else
+ color = layout.pos[mtype]
+ end
+ if table.length <= color then
+ for i in [table.length .. color[ do
+ table[i] = null
+ end
+ end
+ table[color] = mtype
+ end
+ tables[mclasstype] = table
+ end
+ return tables
+ end
+
fun retieve_live_partial_types(mtype: MType) do
# add formal types arguments to mtypes
if mtype isa MGenericType then
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)
+ 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
self.header.add_decl("const char *name;")
self.header.add_decl("int color;")
self.header.add_decl("short int is_nullable;")
- self.header.add_decl("const struct types *unanchored_table;")
+ self.header.add_decl("const struct types *resolution_table;")
self.header.add_decl("int table_size;")
self.header.add_decl("int type_table[{self.type_tables[mtype].length}];")
self.header.add_decl("\};")
v.add_decl("{self.type_layout.ids[mtype]},")
v.add_decl("\"{mtype}\", /* class_name_string */")
var layout = self.type_layout
- if layout isa PHTypeLayout then
+ if layout isa PHLayout[MType, MType] then
v.add_decl("{layout.masks[mtype]},")
else
v.add_decl("{layout.pos[mtype]},")
else
v.add_decl("0,")
end
- if compile_type_unanchored_table(mtype) then
- v.add_decl("(struct types*) &unanchored_table_{c_name},")
+ if compile_type_resolution_table(mtype) then
+ v.add_decl("(struct types*) &resolution_table_{c_name},")
else
v.add_decl("NULL,")
end
v.add_decl("\};")
end
- protected fun compile_type_fts_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 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 */")
- else
- var ntype: MType
- if ft.mclass == mclass_type.mclass then
- ntype = mclass_type.arguments[ft.rank]
- else
- ntype = ft.anchor_to(self.mainmodule, mclass_type)
- end
- if self.type_layout.ids.has_key(ntype) then
- v.add_decl("(struct type*)&type_{ntype.c_name}, /* {ft} ({ntype}) */")
- else
- v.add_decl("NULL, /* empty ({ft} not a live type) */")
- end
- end
- end
- v.add_decl("\},")
- v.add_decl("\};")
- return true
- end
-
- protected fun compile_type_vts_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 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
- v.add_decl("NULL, /* empty */")
- else
- var bound = vt.bound
- if bound == null then
- #FIXME how can a bound be null here ?
- print "No bound found for virtual type {vt} ?"
- abort
- else
- var is_nullable = ""
- if bound isa MNullableType then
- bound = bound.mtype
- is_nullable = "nullable_"
- end
- if bound isa MVirtualType then
- bound = bound.anchor_to(self.mainmodule, mclass_type)
- else if bound isa MParameterType then
- bound = bound.anchor_to(self.mainmodule, mclass_type)
- else if bound isa MGenericType and bound.need_anchor then
- bound = bound.anchor_to(self.mainmodule, mclass_type)
- else if bound isa MClassType then
- else
- print "NOT YET IMPLEMENTED: mtype_to_livetype with type: {bound}"
- abort
- end
-
- if self.type_layout.ids.has_key(bound) then
- v.add_decl("(struct type*)&type_{is_nullable}{bound.c_name}, /* {bound} */")
- else
- v.add_decl("NULL, /* dead type {bound} */")
- end
- end
- end
- end
- v.add_decl("\},")
- v.add_decl("\};")
- return true
- end
-
- fun compile_type_unanchored_table(mtype: MType): Bool do
+ fun compile_type_resolution_table(mtype: MType): Bool do
var mclass_type: MClassType
if mtype isa MNullableType then
else
mclass_type = mtype.as(MClassType)
end
- if not self.unanchored_types_tables.has_key(mclass_type) then return false
+ if not self.resolution_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};")
+ var layout = self.resolution_layout
- 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
+ # extern const struct resolution_table_X resolution_table_X
+ self.header.add_decl("extern const struct resolution_table_{mtype.c_name} resolution_table_{mtype.c_name};")
+ self.header.add_decl("struct resolution_table_{mtype.c_name} \{")
+ if layout isa PHLayout[MClassType, MType] 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("struct type *types[{self.resolution_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]},")
+ v.add_decl("const struct resolution_table_{mtype.c_name} resolution_table_{mtype.c_name} = \{")
+ if layout isa PHLayout[MClassType, MType] then
+ v.add_decl("{layout.masks[mclass_type]},")
end
v.add_decl("\{")
- for t in self.unanchored_types_tables[mclass_type] do
+ for t in self.resolution_tables[mclass_type] do
if t == null then
v.add_decl("NULL, /* empty */")
else
var v = new_visitor
v.add_decl("/* runtime class {c_name} */")
- var idnum = classids.length
- var idname = "ID_" + c_name
- self.classids[mtype] = idname
- #self.header.add_decl("#define {idname} {idnum} /* {c_name} */")
self.header.add_decl("struct class_{c_name} \{")
self.header.add_decl("int box_kind;")
v.add("if(type == NULL) \{")
v.add_abort("type null")
v.add("\}")
- v.add("if(type->unanchored_table == NULL) \{")
+ v.add("if(type->resolution_table == NULL) \{")
v.add("fprintf(stderr, \"Insantiation of a dead type: %s\\n\", type->name);")
v.add_abort("type dead")
v.add("\}")
# Stats
+ private var type_tables: Map[MType, Array[nullable MType]] = new HashMap[MType, Array[nullable MType]]
+ private var resolution_tables: Map[MClassType, Array[nullable MType]] = new HashMap[MClassType, Array[nullable MType]]
+ protected var method_tables: Map[MClass, Array[nullable MPropDef]] = new HashMap[MClass, Array[nullable MPropDef]]
+ protected var attr_tables: Map[MClass, Array[nullable MPropDef]] = new HashMap[MClass, Array[nullable MPropDef]]
+
redef fun display_stats
do
super
- if self.modelbuilder.toolcontext.opt_typing_table_metrics.value then
+ if self.modelbuilder.toolcontext.opt_tables_metrics.value then
display_sizes
end
end
fun display_sizes
do
- print "# size of tables"
- print "\trs size\trs hole\tst size\tst hole"
- var rt_table = 0
- var rt_holes = 0
- var st_table = 0
- var st_holes = 0
- var rtables = unanchored_types_tables
- if rtables != null then
- for unanch, table in rtables do
- rt_table += table.length
- for e in table do if e == null then rt_holes += 1
- end
- end
-
- var ttables = type_tables
- if ttables != null then
- for t, table in ttables do
- st_table += table.length
- for e in table do if e == null then st_holes += 1
- end
- end
- print "\t{rt_table}\t{rt_holes}\t{st_table}\t{st_holes}"
+ print "# size of subtyping tables"
+ print "\ttotal \tholes"
+ var total = 0
+ var holes = 0
+ for t, table in type_tables do
+ total += table.length
+ for e in table do if e == null then holes += 1
+ end
+ print "\t{total}\t{holes}"
+
+ print "# size of resolution tables"
+ print "\ttotal \tholes"
+ total = 0
+ holes = 0
+ for t, table in resolution_tables do
+ total += table.length
+ for e in table do if e == null then holes += 1
+ end
+ print "\t{total}\t{holes}"
+
+ print "# size of methods tables"
+ print "\ttotal \tholes"
+ total = 0
+ holes = 0
+ for t, table in method_tables do
+ total += table.length
+ for e in table do if e == null then holes += 1
+ end
+ print "\t{total}\t{holes}"
+
+ print "# size of attributes tables"
+ print "\ttotal \tholes"
+ total = 0
+ holes = 0
+ for t, table in attr_tables do
+ total += table.length
+ for e in table do if e == null then holes += 1
+ end
+ print "\t{total}\t{holes}"
end
end
return res
end
+ redef fun supercall(m: MMethodDef, recvtype: MClassType, args: Array[RuntimeVariable]): nullable RuntimeVariable
+ do
+ # FIXME implements a polymorphic access in tables
+ m = m.lookup_next_definition(m.mclassdef.mmodule, m.mclassdef.bound_mtype)
+ return self.call(m, recvtype, args)
+ 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
+ # 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.
# One can see this implementation as an inlined method of the receiver whose only
end
end
- # Build livetype structure retrieving
- # ENSURE: mtype.need_anchor
- fun retrieve_anchored_livetype(mtype: MGenericType, buffer: Buffer) do
- assert mtype.need_anchor
-
- var compiler = self.compiler
- for ft in mtype.arguments do
-
- var ntype = ft
- var s: String = ""
- if ntype isa MNullableType then
- ntype = ntype.mtype
- end
-
- var recv = self.frame.arguments.first
- var recv_type_info = self.type_info(recv)
- if ntype isa MParameterType then
- 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
- 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)
- buffer.append("[livetypes_{ntype.mclass.c_name}{bbuff.to_s}->livecolor]")
- else if ntype isa MClassType then
- compiler.undead_types.add(ft)
- buffer.append("[type_{ft.c_name}.livecolor]")
- else
- self.add("printf(\"NOT YET IMPLEMENTED: init_instance(%s, {mtype}).\\n\", \"{ft}\"); exit(1);")
- end
- end
- end
-
redef fun init_instance(mtype)
do
var compiler = self.compiler
if mtype isa MGenericType and mtype.need_anchor then
- link_unanchored_type(self.frame.mpropdef.mclassdef, mtype)
+ link_unresolved_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)
+ return self.new_expr("NEW_{mtype.mclass.c_name}((struct type *) {recv_type_info}->resolution_table->types[HASH({recv_type_info}->resolution_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)
+ return self.new_expr("NEW_{mtype.mclass.c_name}((struct type *) {recv_type_info}->resolution_table->types[{mtype.const_color}])", mtype)
end
end
compiler.undead_types.add(mtype)
var type_struct = self.get_name("type_struct")
self.add_decl("struct type* {type_struct};")
- # Either with unanchored_table with a direct resolution
- link_unanchored_type(self.frame.mpropdef.mclassdef, ntype)
+ # Either with resolution_table with a direct resolution
+ link_unresolved_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})];")
+ self.add("{type_struct} = {recv_type_info}->resolution_table->types[HASH({recv_type_info}->resolution_table->mask, {ntype.const_color})];")
else
- self.add("{type_struct} = {recv_type_info}->unanchored_table->types[{ntype.const_color}];")
+ self.add("{type_struct} = {recv_type_info}->resolution_table->types[{ntype.const_color}];")
end
if compiler.modelbuilder.toolcontext.opt_typing_test_metrics.value then
self.compiler.count_type_test_unresolved[tag] += 1
assert mtype isa MGenericType
var compiler = self.compiler
if mtype.need_anchor then
- link_unanchored_type(self.frame.mpropdef.mclassdef, mtype)
+ link_unresolved_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)
+ return self.new_expr("NEW_{mtype.mclass.c_name}({length}, (struct type *) {recv_type_info}->resolution_table->types[HASH({recv_type_info}->resolution_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)
+ return self.new_expr("NEW_{mtype.mclass.c_name}({length}, (struct type *) {recv_type_info}->resolution_table->types[{mtype.const_color}])", mtype)
end
end
compiler.undead_types.add(mtype)
self.ret(res)
end
- fun link_unanchored_type(mclassdef: MClassDef, mtype: MType) do
+ fun link_unresolved_type(mclassdef: MClassDef, mtype: MType) do
assert mtype.need_anchor
var compiler = self.compiler
- if not compiler.live_unanchored_types.has_key(self.frame.mpropdef.mclassdef) then
- compiler.live_unanchored_types[self.frame.mpropdef.mclassdef] = new HashSet[MType]
+ if not compiler.live_unresolved_types.has_key(self.frame.mpropdef.mclassdef) then
+ compiler.live_unresolved_types[self.frame.mpropdef.mclassdef] = new HashSet[MType]
end
- compiler.live_unanchored_types[self.frame.mpropdef.mclassdef].add(mtype)
+ compiler.live_unresolved_types[self.frame.mpropdef.mclassdef].add(mtype)
end
end