X-Git-Url: http://nitlanguage.org

diff --git a/src/separate_compiler.nit b/src/separate_compiler.nit
index a683a35..4dfbeb0 100644
--- a/src/separate_compiler.nit
+++ b/src/separate_compiler.nit
@@ -16,10 +16,8 @@
 module separate_compiler
 
 import abstract_compiler
-import layout_builders
+import coloring
 import rapid_type_analysis
-import collect_super_sends
-import compiler_ffi
 
 # Add separate compiler specific options
 redef class ToolContext
@@ -32,13 +30,17 @@ redef class ToolContext
 	# --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")
+	var opt_inline_coloring_numbers: OptionBool = new OptionBool("Inline colors and ids (semi-global)", "--inline-coloring-numbers")
+	# --inline-some-methods
+	var opt_inline_some_methods: OptionBool = new OptionBool("Allow the separate compiler to inline some methods (semi-global)", "--inline-some-methods")
+	# --direct-call-monomorph
+	var opt_direct_call_monomorph: OptionBool = new OptionBool("Allow the separate compiler to direct call monomorph sites (semi-global)", "--direct-call-monomorph")
+	# --skip-dead-methods
+	var opt_skip_dead_methods = new OptionBool("Do not compile dead methods (semi-global)", "--skip-dead-methods")
+	# --semi-global
+	var opt_semi_global = new OptionBool("Enable all semi-global optimizations", "--semi-global")
+	# --no-colo-dead-methods
+	var opt_colo_dead_methods = new OptionBool("Force colorization of dead methods", "--colo-dead-methods")
 	# --tables-metrics
 	var opt_tables_metrics: OptionBool = new OptionBool("Enable static size measuring of tables used for vft, typing and resolution", "--tables-metrics")
 
@@ -49,12 +51,36 @@ redef class ToolContext
 		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_inline_coloring_numbers, opt_inline_some_methods, opt_direct_call_monomorph, opt_skip_dead_methods, opt_semi_global)
+		self.option_context.add_option(self.opt_colo_dead_methods)
 		self.option_context.add_option(self.opt_tables_metrics)
 	end
+
+	redef fun process_options(args)
+	do
+		super
+
+		var tc = self
+		if tc.opt_semi_global.value then
+			tc.opt_inline_coloring_numbers.value = true
+			tc.opt_inline_some_methods.value = true
+			tc.opt_direct_call_monomorph.value = true
+			tc.opt_skip_dead_methods.value = true
+		end
+	end
+
+	var separate_compiler_phase = new SeparateCompilerPhase(self, null)
+end
+
+class SeparateCompilerPhase
+	super Phase
+	redef fun process_mainmodule(mainmodule, given_mmodules) do
+		if not toolcontext.opt_separate.value then return
+
+		var modelbuilder = toolcontext.modelbuilder
+		var analysis = modelbuilder.do_rapid_type_analysis(mainmodule)
+		modelbuilder.run_separate_compiler(mainmodule, analysis)
+	end
 end
 
 redef class ModelBuilder
@@ -79,7 +105,9 @@ redef class ModelBuilder
 
 		# The main function of the C
 		compiler.new_file("{mainmodule.name}.main")
+		compiler.compile_nitni_global_ref_functions
 		compiler.compile_main_function
+		compiler.compile_finalizer_function
 
 		# compile methods
 		for m in mainmodule.in_importation.greaters do
@@ -95,6 +123,11 @@ redef class ModelBuilder
 		for t in mtypes do
 			compiler.compile_type_to_c(t)
 		end
+		# compile remaining types structures (useless but needed for the symbol resolution at link-time)
+		for t in compiler.undead_types do
+			if mtypes.has(t) then continue
+			compiler.compile_type_to_c(t)
+		end
 
 		compiler.display_stats
 
@@ -102,6 +135,13 @@ redef class ModelBuilder
 		self.toolcontext.info("*** END GENERATING C: {time1-time0} ***", 2)
 		write_and_make(compiler)
 	end
+
+	# Count number of invocations by VFT
+	private var nb_invok_by_tables = 0
+	# Count number of invocations by direct call
+	private var nb_invok_by_direct = 0
+	# Count number of invocations by inlining
+	private var nb_invok_by_inline = 0
 end
 
 # Singleton that store the knowledge about the separate compilation process
@@ -114,13 +154,13 @@ class SeparateCompiler
 	var runtime_type_analysis: nullable RapidTypeAnalysis
 
 	private var undead_types: Set[MType] = new HashSet[MType]
-	private var partial_types: Set[MType] = new HashSet[MType]
 	private var live_unresolved_types: Map[MClassDef, Set[MType]] = new HashMap[MClassDef, HashSet[MType]]
 
-	private var type_layout: nullable Layout[MType]
-	private var resolution_layout: nullable Layout[MType]
-	protected var method_layout: nullable Layout[PropertyLayoutElement]
-	protected var attr_layout: nullable Layout[MAttribute]
+	private var type_ids: Map[MType, Int]
+	private var type_colors: Map[MType, Int]
+	private var opentype_colors: Map[MType, Int]
+	protected var method_colors: Map[PropertyLayoutElement, Int]
+	protected var attr_colors: Map[MAttribute, Int]
 
 	init(mainmodule: MModule, mmbuilder: ModelBuilder, runtime_type_analysis: nullable RapidTypeAnalysis) do
 		super(mainmodule, mmbuilder)
@@ -138,19 +178,7 @@ class SeparateCompiler
 		# 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; const struct types *resolution_table; int table_size; int type_table[]; \}; /* general C type representing a Nit type. */")
 		self.header.add_decl("struct instance \{ const struct type *type; const struct class *class; nitattribute_t attrs[]; \}; /* general C type representing a Nit instance. */")
-
-		if modelbuilder.toolcontext.opt_phmod_typing.value or modelbuilder.toolcontext.opt_phand_typing.value then
-			self.header.add_decl("struct types \{ int mask; const struct type *types[]; \}; /* a list types (used for vts, fts and unresolved lists). */")
-		else
-			self.header.add_decl("struct types \{ int dummy; const struct type *types[]; \}; /* 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("struct types \{ int dummy; const struct type *types[]; \}; /* a list types (used for vts, fts and unresolved lists). */")
 		self.header.add_decl("typedef struct instance val; /* general C type representing a Nit instance. */")
 	end
 
@@ -233,28 +261,17 @@ class SeparateCompiler
 
 	# colorize classe properties
 	fun do_property_coloring do
-		var mclasses = new HashSet[MClass].from(modelbuilder.model.mclasses)
+
+		var rta = runtime_type_analysis
 
 		# Layouts
-		var method_layout_builder: PropertyLayoutBuilder[PropertyLayoutElement]
-		var attribute_layout_builder: PropertyLayoutBuilder[MAttribute]
-		#FIXME PH and BM layouts too slow for large programs
-		#if modelbuilder.toolcontext.opt_bm_typing.value then
-		#	method_layout_builder = new MMethodBMizer(self.mainmodule)
-		#	attribute_layout_builder = new MAttributeBMizer(self.mainmodule)
-		#else if modelbuilder.toolcontext.opt_phmod_typing.value then
-		#	method_layout_builder = new MMethodHasher(new PHModOperator, self.mainmodule)
-		#	attribute_layout_builder = new MAttributeHasher(new PHModOperator, self.mainmodule)
-		#else if modelbuilder.toolcontext.opt_phand_typing.value then
-		#	method_layout_builder = new MMethodHasher(new PHAndOperator, self.mainmodule)
-		#	attribute_layout_builder = new MAttributeHasher(new PHAndOperator, self.mainmodule)
-		#else
-
-		var class_layout_builder = new MClassColorer(self.mainmodule)
-		class_layout_builder.build_layout(mclasses)
-		method_layout_builder = new MPropertyColorer[PropertyLayoutElement](self.mainmodule, class_layout_builder)
-		attribute_layout_builder = new MPropertyColorer[MAttribute](self.mainmodule, class_layout_builder)
-		#end
+		var poset = mainmodule.flatten_mclass_hierarchy
+		var mclasses = new HashSet[MClass].from(poset)
+		var colorer = new POSetColorer[MClass]
+		colorer.colorize(poset)
+
+		# The dead methods, still need to provide a dead color symbol
+		var dead_methods = new Array[MMethod]
 
 		# lookup properties to build layout with
 		var mmethods = new HashMap[MClass, Set[PropertyLayoutElement]]
@@ -264,6 +281,10 @@ class SeparateCompiler
 			mattributes[mclass] = new HashSet[MAttribute]
 			for mprop in self.mainmodule.properties(mclass) do
 				if mprop isa MMethod then
+					if not modelbuilder.toolcontext.opt_colo_dead_methods.value and rta != null and not rta.live_methods.has(mprop) then
+						dead_methods.add(mprop)
+						continue
+					end
 					mmethods[mclass].add(mprop)
 				else if mprop isa MAttribute then
 					mattributes[mclass].add(mprop)
@@ -271,13 +292,27 @@ class SeparateCompiler
 			end
 		end
 
+		# Collect all super calls (dead or not)
+		var all_super_calls = new HashSet[MMethodDef]
+		for mmodule in self.mainmodule.in_importation.greaters do
+			for mclassdef in mmodule.mclassdefs do
+				for mpropdef in mclassdef.mpropdefs do
+					if not mpropdef isa MMethodDef then continue
+					if mpropdef.has_supercall then
+						all_super_calls.add(mpropdef)
+					end
+				end
+			end
+		end
+
 		# lookup super calls and add it to the list of mmethods to build layout with
 		var super_calls
-		if runtime_type_analysis != null then
-			super_calls = runtime_type_analysis.live_super_sends
+		if rta != null then
+			super_calls = rta.live_super_sends
 		else
-			super_calls = modelbuilder.collect_super_sends
+			super_calls = all_super_calls
 		end
+
 		for mmethoddef in super_calls do
 			var mclass = mmethoddef.mclassdef.mclass
 			mmethods[mclass].add(mmethoddef)
@@ -287,188 +322,108 @@ class SeparateCompiler
 		end
 
 		# methods coloration
-		self.method_layout = method_layout_builder.build_layout(mmethods)
-		self.method_tables = build_method_tables(mclasses, super_calls)
-		self.compile_color_consts(method_layout.pos)
+		var meth_colorer = new POSetBucketsColorer[MClass, PropertyLayoutElement](poset, colorer.conflicts)
+		method_colors = meth_colorer.colorize(mmethods)
+		method_tables = build_method_tables(mclasses, super_calls)
+		compile_color_consts(method_colors)
 
-		# attribute null color to dead supercalls
-		for mmodule in self.mainmodule.in_importation.greaters do
-			for mclassdef in mmodule.mclassdefs do
-				for mpropdef in mclassdef.mpropdefs do
-					if mpropdef.has_supercall then
-						compile_color_const(new_visitor, mpropdef, -1)
-					end
-				end
-			end
+		# attribute null color to dead methods and supercalls
+		for mproperty in dead_methods do
+			compile_color_const(new_visitor, mproperty, -1)
+		end
+		for mpropdef in all_super_calls do
+			if super_calls.has(mpropdef) then continue
+			compile_color_const(new_visitor, mpropdef, -1)
 		end
 
 		# attributes coloration
-		self.attr_layout = attribute_layout_builder.build_layout(mattributes)
-		self.attr_tables = build_attr_tables(mclasses)
-		self.compile_color_consts(attr_layout.pos)
+		var attr_colorer = new POSetBucketsColorer[MClass, MAttribute](poset, colorer.conflicts)
+		attr_colors = attr_colorer.colorize(mattributes)
+		attr_tables = build_attr_tables(mclasses)
+		compile_color_consts(attr_colors)
 	end
 
 	fun build_method_tables(mclasses: Set[MClass], super_calls: Set[MMethodDef]): Map[MClass, Array[nullable MPropDef]] do
-		var layout = self.method_layout
 		var tables = new HashMap[MClass, Array[nullable MPropDef]]
 		for mclass in mclasses do
 			var table = new Array[nullable MPropDef]
-			var supercalls = new List[MMethodDef]
-
-			# first, fill table from parents by reverse linearization order
-			var parents = new Array[MClass]
-			if mainmodule.flatten_mclass_hierarchy.has(mclass) then
-				parents = mclass.in_hierarchy(mainmodule).greaters.to_a
-				self.mainmodule.linearize_mclasses(parents)
-			end
-
-			for parent in parents do
-				if parent == mclass then continue
-				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
+			tables[mclass] = table
 
-				# lookup for super calls in super classes
-				for mmethoddef in super_calls do
-					for mclassdef in parent.mclassdefs do
-						if mclassdef.mpropdefs.has(mmethoddef) then
-							supercalls.add(mmethoddef)
-						end
-					end
-				end
-			end
+			var mproperties = self.mainmodule.properties(mclass)
+			var mtype = mclass.intro.bound_mtype
 
-			# then override with local properties
-			for mproperty in self.mainmodule.properties(mclass) do
+			for mproperty in mproperties do
 				if not mproperty isa MMethod then continue
-				var color = layout.pos[mproperty]
+				if not method_colors.has_key(mproperty) then continue
+				var color = method_colors[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
+				table[color] = mproperty.lookup_first_definition(mainmodule, mtype)
 			end
 
-			# lookup for super calls in local class
-			for mmethoddef in super_calls do
-				for mclassdef in mclass.mclassdefs do
-					if mclassdef.mpropdefs.has(mmethoddef) then
-						supercalls.add(mmethoddef)
-					end
-				end
-			end
-			# insert super calls in table according to receiver
-			for supercall in supercalls do
-				var color = layout.pos[supercall]
+			for supercall in super_calls do
+				if not mtype.collect_mclassdefs(mainmodule).has(supercall.mclassdef) then continue
+
+				var color = method_colors[supercall]
 				if table.length <= color then
 					for i in [table.length .. color[ do
 						table[i] = null
 					end
 				end
-				var mmethoddef = supercall.lookup_next_definition(self.mainmodule, mclass.intro.bound_mtype)
+				var mmethoddef = supercall.lookup_next_definition(mainmodule, mtype)
 				table[color] = mmethoddef
 			end
-			tables[mclass] = table
+
 		end
 		return tables
 	end
 
 	fun build_attr_tables(mclasses: Set[MClass]): Map[MClass, Array[nullable MPropDef]] do
-		var layout = self.attr_layout
 		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 = new Array[MClass]
-			if mainmodule.flatten_mclass_hierarchy.has(mclass) then
-				parents = mclass.in_hierarchy(mainmodule).greaters.to_a
-				self.mainmodule.linearize_mclasses(parents)
-			end
-			for parent in parents do
-				if parent == mclass then continue
-				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
+			tables[mclass] = table
+
+			var mproperties = self.mainmodule.properties(mclass)
+			var mtype = mclass.intro.bound_mtype
 
-			# then override with local properties
-			for mproperty in self.mainmodule.properties(mclass) do
+			for mproperty in mproperties do
 				if not mproperty isa MAttribute then continue
-				var color = layout.pos[mproperty]
+				if not attr_colors.has_key(mproperty) then continue
+				var color = attr_colors[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
+				table[color] = mproperty.lookup_first_definition(mainmodule, mtype)
 			end
-			tables[mclass] = table
 		end
 		return tables
 	end
 
 	# colorize live types of the program
 	private fun do_type_coloring: POSet[MType] do
+		# Collect types to colorize
+		var live_types = runtime_type_analysis.live_types
+		var live_cast_types = runtime_type_analysis.live_cast_types
 		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)
+		mtypes.add_all(live_types)
+		mtypes.add_all(live_cast_types)
 		for c in self.box_kinds.keys do
 			mtypes.add(c.mclass_type)
 		end
 
-		for mtype in mtypes do
-			retrieve_partial_types(mtype)
-		end
-		mtypes.add_all(self.partial_types)
-
-		# Typing Layout
-		var layout_builder: TypingLayoutBuilder[MType]
-		if modelbuilder.toolcontext.opt_bm_typing.value then
-			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
-			layout_builder = new MTypeColorer(self.mainmodule)
-		end
-
-		# colorize types
-		self.type_layout = layout_builder.build_layout(mtypes)
-		var poset = layout_builder.poset.as(not null)
-		self.type_tables = self.build_type_tables(poset)
+		# Compute colors
+		var poset = poset_from_mtypes(mtypes)
+		var colorer = new POSetColorer[MType]
+		colorer.colorize(poset)
+		type_ids = colorer.ids
+		type_colors = colorer.colors
+		type_tables = build_type_tables(poset)
 
 		# VT and FT are stored with other unresolved types in the big resolution_tables
 		self.compile_resolution_tables(mtypes)
@@ -476,19 +431,27 @@ class SeparateCompiler
 		return poset
 	end
 
+	private fun poset_from_mtypes(mtypes: Set[MType]): POSet[MType] do
+		var poset = new POSet[MType]
+		for e in mtypes do
+			poset.add_node(e)
+			for o in mtypes do
+				if e == o then continue
+				if e.is_subtype(mainmodule, null, o) then
+					poset.add_edge(e, o)
+				end
+			end
+		end
+		return poset
+	end
+
 	# Build type tables
 	fun build_type_tables(mtypes: POSet[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]
 			for sup in mtypes[mtype].greaters do
-				var color: Int
-				if layout isa PHLayout[MType, MType] then
-					color = layout.hashes[mtype][sup]
-				else
-					color = layout.pos[sup]
-				end
+				var color = type_colors[sup]
 				if table.length <= color then
 					for i in [table.length .. color[ do
 						table[i] = null
@@ -521,18 +484,9 @@ class SeparateCompiler
 		end
 
 		# Compute the table layout with the prefered method
-		var resolution_builder: ResolutionLayoutBuilder
-		if modelbuilder.toolcontext.opt_bm_typing.value then
-			resolution_builder = new ResolutionBMizer
-		else if modelbuilder.toolcontext.opt_phmod_typing.value then
-			resolution_builder = new ResolutionHasher(new PHModOperator)
-		else if modelbuilder.toolcontext.opt_phand_typing.value then
-			resolution_builder = new ResolutionHasher(new PHAndOperator)
-		else
-			resolution_builder = new ResolutionColorer
-		end
-		self.resolution_layout = resolution_builder.build_layout(mtype2unresolved)
-		self.resolution_tables = self.build_resolution_tables(mtype2unresolved)
+		var colorer = new BucketsColorer[MType, MType]
+		opentype_colors = colorer.colorize(mtype2unresolved)
+		resolution_tables = self.build_resolution_tables(mtype2unresolved)
 
 		# 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)
@@ -542,8 +496,8 @@ class SeparateCompiler
 		end
 		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]
+			if opentype_colors.has_key(t) then
+				all_unresolved_types_colors[t] = opentype_colors[t]
 			else
 				all_unresolved_types_colors[t] = -1
 			end
@@ -559,16 +513,10 @@ class SeparateCompiler
 
 	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
+				var color = opentype_colors[mtype]
 				if table.length <= color then
 					for i in [table.length .. color[ do
 						table[i] = null
@@ -581,34 +529,6 @@ class SeparateCompiler
 		return tables
 	end
 
-	fun retrieve_partial_types(mtype: MType) do
-		# add formal types arguments to mtypes
-		if mtype isa MGenericType then
-			for ft in mtype.arguments do
-				if ft.need_anchor then
-					print("Why do we need anchor here ?")
-					abort
-				end
-				self.partial_types.add(ft)
-				retrieve_partial_types(ft)
-			end
-		end
-		var mclass_type: MClassType
-		if mtype isa MNullableType then
-			mclass_type = mtype.mtype.as(MClassType)
-		else
-			mclass_type = mtype.as(MClassType)
-		end
-
-		# add virtual types to mtypes
-		for vt in self.mainmodule.properties(mclass_type.mclass) do
-			if vt isa MVirtualTypeProp then
-				var anchored = vt.mvirtualtype.lookup_bound(self.mainmodule, mclass_type).anchor_to(self.mainmodule, mclass_type)
-				self.partial_types.add(anchored)
-			end
-		end
-	end
-
 	# Separately compile all the method definitions of the module
 	fun compile_module_to_c(mmodule: MModule)
 	do
@@ -617,6 +537,8 @@ class SeparateCompiler
 		for cd in mmodule.mclassdefs do
 			for pd in cd.mpropdefs do
 				if not pd isa MMethodDef then continue
+				var rta = runtime_type_analysis
+				if modelbuilder.toolcontext.opt_skip_dead_methods.value and rta != null and not rta.live_methoddefs.has(pd) then continue
 				#print "compile {pd} @ {cd} @ {mmodule}"
 				var r = pd.separate_runtime_function
 				r.compile_to_c(self)
@@ -631,7 +553,6 @@ class SeparateCompiler
 	fun compile_type_to_c(mtype: MType)
 	do
 		assert not mtype.need_anchor
-		var layout = self.type_layout
 		var is_live = mtype isa MClassType and runtime_type_analysis.live_types.has(mtype)
 		var is_cast_live = runtime_type_analysis.live_cast_types.has(mtype)
 		var c_name = mtype.c_name
@@ -646,7 +567,7 @@ class SeparateCompiler
 
 		# type id (for cast target)
 		if is_cast_live then
-			v.add_decl("{layout.ids[mtype]},")
+			v.add_decl("{type_ids[mtype]},")
 		else
 			v.add_decl("-1, /*CAST DEAD*/")
 		end
@@ -656,11 +577,7 @@ class SeparateCompiler
 
 		# type color (for cast target)
 		if is_cast_live then
-			if layout isa PHLayout[MType, MType] then
-				v.add_decl("{layout.masks[mtype]},")
-			else
-				v.add_decl("{layout.pos[mtype]},")
-			end
+			v.add_decl("{type_colors[mtype]},")
 		else
 			v.add_decl("-1, /*CAST DEAD*/")
 		end
@@ -674,8 +591,7 @@ class SeparateCompiler
 
 		# resolution table (for receiver)
 		if is_live then
-			var mclass_type = mtype
-			if mclass_type isa MNullableType then mclass_type = mclass_type.mtype
+			var mclass_type = mtype.as_notnullable
 			assert mclass_type isa MClassType
 			if resolution_tables[mclass_type].is_empty then
 				v.add_decl("NULL, /*NO RESOLUTIONS*/")
@@ -696,7 +612,7 @@ class SeparateCompiler
 				if stype == null then
 					v.add_decl("-1, /* empty */")
 				else
-					v.add_decl("{layout.ids[stype]}, /* {stype} */")
+					v.add_decl("{type_ids[stype]}, /* {stype} */")
 				end
 			end
 			v.add_decl("\},")
@@ -708,14 +624,7 @@ class SeparateCompiler
 
 	fun compile_type_resolution_table(mtype: MType) do
 
-		var mclass_type: MClassType
-		if mtype isa MNullableType then
-			mclass_type = mtype.mtype.as(MClassType)
-		else
-			mclass_type = mtype.as(MClassType)
-		end
-
-		var layout = self.resolution_layout
+		var mclass_type = mtype.as_notnullable.as(MClassType)
 
 		# extern const struct resolution_table_X resolution_table_X
 		self.provide_declaration("resolution_table_{mtype.c_name}", "extern const struct types resolution_table_{mtype.c_name};")
@@ -723,11 +632,7 @@ class SeparateCompiler
 		# const struct fts_table_X fts_table_X
 		var v = new_visitor
 		v.add_decl("const struct types resolution_table_{mtype.c_name} = \{")
-		if layout isa PHLayout[MClassType, MType] then
-			v.add_decl("{layout.masks[mclass_type]},")
-		else
-			v.add_decl("0, /* dummy */")
-		end
+		v.add_decl("0, /* dummy */")
 		v.add_decl("\{")
 		for t in self.resolution_tables[mclass_type] do
 			if t == null then
@@ -738,7 +643,7 @@ class SeparateCompiler
 				# 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.type_layout.ids.has_key(tv) then
+				if type_ids.has_key(tv) then
 					v.require_declaration("type_{tv.c_name}")
 					v.add_decl("&type_{tv.c_name}, /* {t}: {tv} */")
 				else
@@ -757,12 +662,14 @@ class SeparateCompiler
 	do
 		var mtype = mclass.intro.bound_mtype
 		var c_name = mclass.c_name
+		var c_instance_name = mclass.c_instance_name
 
 		var vft = self.method_tables[mclass]
 		var attrs = self.attr_tables[mclass]
 		var v = new_visitor
 
-		var is_dead = runtime_type_analysis != null and not runtime_type_analysis.live_classes.has(mclass) and mtype.ctype == "val*" and mclass.name != "NativeArray"
+		var rta = runtime_type_analysis
+		var is_dead = rta != null and not rta.live_classes.has(mclass) and mtype.ctype == "val*" and mclass.name != "NativeArray"
 
 		v.add_decl("/* runtime class {c_name} */")
 
@@ -778,6 +685,10 @@ class SeparateCompiler
 					v.add_decl("NULL, /* empty */")
 				else
 					assert mpropdef isa MMethodDef
+					if rta != null and not rta.live_methoddefs.has(mpropdef) then
+						v.add_decl("NULL, /* DEAD {mclass.intro_mmodule}:{mclass}:{mpropdef} */")
+						continue
+					end
 					var rf = mpropdef.virtual_runtime_function
 					v.require_declaration(rf.c_name)
 					v.add_decl("(nitmethod_t){rf.c_name}, /* pointer to {mclass.intro_mmodule}:{mclass}:{mpropdef} */")
@@ -788,20 +699,22 @@ class SeparateCompiler
 		end
 
 		if mtype.ctype != "val*" then
-			#Build instance struct
-			self.header.add_decl("struct instance_{c_name} \{")
-			self.header.add_decl("const struct type *type;")
-			self.header.add_decl("const struct class *class;")
-			self.header.add_decl("{mtype.ctype} value;")
-			self.header.add_decl("\};")
+			if mtype.mclass.name == "Pointer" or mtype.mclass.kind != extern_kind then
+				#Build instance struct
+				self.header.add_decl("struct instance_{c_instance_name} \{")
+				self.header.add_decl("const struct type *type;")
+				self.header.add_decl("const struct class *class;")
+				self.header.add_decl("{mtype.ctype} value;")
+				self.header.add_decl("\};")
+			end
 
-			if not self.runtime_type_analysis.live_types.has(mtype) then return
+			if not rta.live_types.has(mtype) then return
 
 			#Build BOX
-			self.header.add_decl("val* BOX_{c_name}({mtype.ctype});")
+			self.provide_declaration("BOX_{c_name}", "val* BOX_{c_name}({mtype.ctype});")
 			v.add_decl("/* allocate {mtype} */")
 			v.add_decl("val* BOX_{mtype.c_name}({mtype.ctype} value) \{")
-			v.add("struct instance_{c_name}*res = nit_alloc(sizeof(struct instance_{c_name}));")
+			v.add("struct instance_{c_instance_name}*res = nit_alloc(sizeof(struct instance_{c_instance_name}));")
 			v.require_declaration("type_{c_name}")
 			v.add("res->type = &type_{c_name};")
 			v.require_declaration("class_{c_name}")
@@ -812,10 +725,11 @@ class SeparateCompiler
 			return
 		else if mclass.name == "NativeArray" then
 			#Build instance struct
-			self.header.add_decl("struct instance_{c_name} \{")
+			self.header.add_decl("struct instance_{c_instance_name} \{")
 			self.header.add_decl("const struct type *type;")
 			self.header.add_decl("const struct class *class;")
-			# NativeArrays are just a instance header followed by an array of values
+			# NativeArrays are just a instance header followed by a length and an array of values
+			self.header.add_decl("int length;")
 			self.header.add_decl("val* values[0];")
 			self.header.add_decl("\};")
 
@@ -823,15 +737,16 @@ class SeparateCompiler
 			self.provide_declaration("NEW_{c_name}", "{mtype.ctype} NEW_{c_name}(int length, const struct type* type);")
 			v.add_decl("/* allocate {mtype} */")
 			v.add_decl("{mtype.ctype} NEW_{c_name}(int length, const struct type* type) \{")
-			var res = v.new_named_var(mtype, "self")
-			res.is_exact = true
+			var res = v.get_name("self")
+			v.add_decl("struct instance_{c_instance_name} *{res};")
 			var mtype_elt = mtype.arguments.first
-			v.add("{res} = nit_alloc(sizeof(struct instance_{c_name}) + length*sizeof({mtype_elt.ctype}));")
+			v.add("{res} = nit_alloc(sizeof(struct instance_{c_instance_name}) + length*sizeof({mtype_elt.ctype}));")
 			v.add("{res}->type = type;")
 			hardening_live_type(v, "type")
 			v.require_declaration("class_{c_name}")
 			v.add("{res}->class = &class_{c_name};")
-			v.add("return {res};")
+			v.add("{res}->length = length;")
+			v.add("return (val*){res};")
 			v.add("\}")
 			return
 		end
@@ -851,6 +766,7 @@ class SeparateCompiler
 			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("\}")
@@ -864,7 +780,7 @@ class SeparateCompiler
 		v.add_abort("type null")
 		v.add("\}")
 		v.add("if({t}->table_size == 0) \{")
-		v.add("fprintf(stderr, \"Insantiation of a dead type: %s\\n\", {t}->name);")
+		v.add("PRINT_ERROR(\"Insantiation of a dead type: %s\\n\", {t}->name);")
 		v.add_abort("type dead")
 		v.add("\}")
 	end
@@ -884,6 +800,16 @@ class SeparateCompiler
 		if self.modelbuilder.toolcontext.opt_tables_metrics.value then
 			display_sizes
 		end
+		if self.modelbuilder.toolcontext.opt_isset_checks_metrics.value then
+			display_isset_checks
+		end
+		var tc = self.modelbuilder.toolcontext
+		tc.info("# implementation of method invocation",2)
+		var nb_invok_total = modelbuilder.nb_invok_by_tables + modelbuilder.nb_invok_by_direct + modelbuilder.nb_invok_by_inline
+		tc.info("total number of invocations: {nb_invok_total}",2)
+		tc.info("invocations by VFT send:     {modelbuilder.nb_invok_by_tables} ({div(modelbuilder.nb_invok_by_tables,nb_invok_total)}%)",2)
+		tc.info("invocations by direct call:  {modelbuilder.nb_invok_by_direct} ({div(modelbuilder.nb_invok_by_direct,nb_invok_total)}%)",2)
+		tc.info("invocations by inlining:     {modelbuilder.nb_invok_by_inline} ({div(modelbuilder.nb_invok_by_inline,nb_invok_total)}%)",2)
 	end
 
 	fun display_sizes
@@ -929,15 +855,35 @@ class SeparateCompiler
 		print "\t{total}\t{holes}"
 	end
 
+	protected var isset_checks_count = 0
+	protected var attr_read_count = 0
+
+	fun display_isset_checks do
+		print "# total number of compiled attribute reads"
+		print "\t{attr_read_count}"
+		print "# total number of compiled isset-checks"
+		print "\t{isset_checks_count}"
+	end
+
 	redef fun compile_nitni_structs
 	do
-		self.header.add_decl("struct nitni_instance \{struct instance *value;\};")
+		self.header.add_decl """
+struct nitni_instance \{
+	struct nitni_instance *next,
+		*prev; /* adjacent global references in global list */
+	int count; /* number of time this global reference has been marked */
+	struct instance *value;
+\};
+"""
+		super
 	end
-	
-	redef fun finalize_ffi_for_module(nmodule)
+
+	redef fun finalize_ffi_for_module(mmodule)
 	do
-		self.mainmodule = nmodule.mmodule.as(not null)
+		var old_module = self.mainmodule
+		self.mainmodule = mmodule
 		super
+		self.mainmodule = old_module
 	end
 end
 
@@ -970,24 +916,27 @@ class SeparateCompilerVisitor
 		else if value.mtype.ctype == "val*" and mtype.ctype == "val*" then
 			return value
 		else if value.mtype.ctype == "val*" then
-			return self.new_expr("((struct instance_{mtype.c_name}*){value})->value; /* autounbox from {value.mtype} to {mtype} */", mtype)
+			return self.new_expr("((struct instance_{mtype.c_instance_name}*){value})->value; /* autounbox from {value.mtype} to {mtype} */", mtype)
 		else if mtype.ctype == "val*" then
 			var valtype = value.mtype.as(MClassType)
 			var res = self.new_var(mtype)
 			if compiler.runtime_type_analysis != null and not compiler.runtime_type_analysis.live_types.has(valtype) then
 				self.add("/*no autobox from {value.mtype} to {mtype}: {value.mtype} is not live! */")
-				self.add("printf(\"Dead code executed!\\n\"); show_backtrace(1);")
+				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}); /* autobox from {value.mtype} to {mtype} */")
 			return res
-		else if value.mtype.cname_blind == "void*" and mtype.cname_blind == "void*" then
+		else if (value.mtype.ctype == "void*" and mtype.ctype == "void*") or
+			(value.mtype.ctype == "char*" and mtype.ctype == "void*") or
+			(value.mtype.ctype == "void*" and mtype.ctype == "char*") then
 			return value
 		else
 			# Bad things will appen!
 			var res = self.new_var(mtype)
 			self.add("/* {res} left unintialized (cannot convert {value.mtype} to {mtype}) */")
-			self.add("printf(\"Cast error: Cannot cast %s to %s.\\n\", \"{value.mtype}\", \"{mtype}\"); show_backtrace(1);")
+			self.add("PRINT_ERROR(\"Cast error: Cannot cast %s to %s.\\n\", \"{value.mtype}\", \"{mtype}\"); show_backtrace(1);")
 			return res
 		end
 	end
@@ -999,11 +948,36 @@ class SeparateCompilerVisitor
 		if value.mtype.ctype == "val*" then
 			return "{value}->type"
 		else
+			compiler.undead_types.add(value.mtype)
 			self.require_declaration("type_{value.mtype.c_name}")
 			return "(&type_{value.mtype.c_name})"
 		end
 	end
 
+	redef fun compile_callsite(callsite, args)
+	do
+		var rta = compiler.runtime_type_analysis
+		var recv = args.first.mtype
+		var mmethod = callsite.mproperty
+		# TODO: Inlining of new-style constructors
+		if compiler.modelbuilder.toolcontext.opt_direct_call_monomorph.value and rta != null and not mmethod.is_root_init then
+			var tgs = rta.live_targets(callsite)
+			if tgs.length == 1 then
+				# DIRECT CALL
+				self.varargize(mmethod.intro, mmethod.intro.msignature.as(not null), args)
+				var res0 = before_send(mmethod, args)
+				var res = call(tgs.first, tgs.first.mclassdef.bound_mtype, args)
+				if res0 != null then
+					assert res != null
+					self.assign(res0, res)
+					res = res0
+				end
+				add("\}") # close the before_send
+				return res
+			end
+		end
+		return super
+	end
 	redef fun send(mmethod, arguments)
 	do
 		self.varargize(mmethod.intro, mmethod.intro.msignature.as(not null), arguments)
@@ -1021,43 +995,27 @@ class SeparateCompilerVisitor
 		return table_send(mmethod, arguments, mmethod.const_color)
 	end
 
-	private fun table_send(mmethod: MMethod, arguments: Array[RuntimeVariable], const_color: String): nullable RuntimeVariable
+	# Handel common special cases before doing the effective method invocation
+	# This methods handle the `==` and `!=` methods and the case of the null receiver.
+	# Note: a { is open in the generated C, that enclose and protect the effective method invocation.
+	# Client must not forget to close the } after them.
+	#
+	# The value returned is the result of the common special cases.
+	# If not null, client must compine it with the result of their own effective method invocation.
+	#
+	# If `before_send` can shortcut the whole message sending, a dummy `if(0){`
+	# is generated to cancel the effective method invocation that will follow
+	# TODO: find a better approach
+	private fun before_send(mmethod: MMethod, arguments: Array[RuntimeVariable]): nullable RuntimeVariable
 	do
-		var res: nullable RuntimeVariable
-		var msignature = mmethod.intro.msignature.resolve_for(mmethod.intro.mclassdef.bound_mtype, mmethod.intro.mclassdef.bound_mtype, mmethod.intro.mclassdef.mmodule, true)
-		var ret = msignature.return_mtype
-		if mmethod.is_new then
-			ret = arguments.first.mtype
-			res = self.new_var(ret)
-		else if ret == null then
-			res = null
-		else
-			res = self.new_var(ret)
-		end
-
-		var s = new Buffer
-		var ss = new Buffer
-
+		var res: nullable RuntimeVariable = null
 		var recv = arguments.first
-		s.append("val*")
-		ss.append("{recv}")
-		for i in [0..msignature.arity[ do
-			var a = arguments[i+1]
-			var t = msignature.mparameters[i].mtype
-			if i == msignature.vararg_rank then
-				t = arguments[i+1].mcasttype
-			end
-			s.append(", {t.ctype}")
-			a = self.autobox(a, t)
-			ss.append(", {a}")
-		end
-
-		var consider_null = not self.compiler.modelbuilder.toolcontext.opt_no_check_other.value or mmethod.name == "==" or mmethod.name == "!="
+		var consider_null = not self.compiler.modelbuilder.toolcontext.opt_no_check_null.value or mmethod.name == "==" or mmethod.name == "!="
 		var maybenull = recv.mcasttype isa MNullableType and consider_null
 		if maybenull then
 			self.add("if ({recv} == NULL) \{")
 			if mmethod.name == "==" then
-				assert res != null
+				res = self.new_var(bool_type)
 				var arg = arguments[1]
 				if arg.mcasttype isa MNullableType then
 					self.add("{res} = ({arg} == NULL);")
@@ -1067,7 +1025,7 @@ class SeparateCompilerVisitor
 					self.add("{res} = 0; /* {arg.inspect} cannot be null */")
 				end
 			else if mmethod.name == "!=" then
-				assert res != null
+				res = self.new_var(bool_type)
 				var arg = arguments[1]
 				if arg.mcasttype isa MNullableType then
 					self.add("{res} = ({arg} != NULL);")
@@ -1077,12 +1035,14 @@ class SeparateCompilerVisitor
 					self.add("{res} = 1; /* {arg.inspect} cannot be null */")
 				end
 			else
-				self.add_abort("Reciever is null")
+				self.add_abort("Receiver is null")
 			end
 			self.add("\} else \{")
+		else
+			self.add("\{")
 		end
 		if not self.compiler.modelbuilder.toolcontext.opt_no_shortcut_equate.value and (mmethod.name == "==" or mmethod.name == "!=") then
-			assert res != null
+			if res == null then res = self.new_var(bool_type)
 			# Recv is not null, thus is arg is, it is easy to conclude (and respect the invariants)
 			var arg = arguments[1]
 			if arg.mcasttype isa MNullType then
@@ -1091,12 +1051,51 @@ class SeparateCompilerVisitor
 				else
 					self.add("{res} = 1; /* arg is null and recv is not */")
 				end
-				if maybenull then
-					self.add("\}")
-				end
-				return res
+				self.add("\}") # closes the null case
+				self.add("if (0) \{") # what follow is useless, CC will drop it
 			end
 		end
+		return res
+	end
+
+	private fun table_send(mmethod: MMethod, arguments: Array[RuntimeVariable], const_color: String): nullable RuntimeVariable
+	do
+		compiler.modelbuilder.nb_invok_by_tables += 1
+		if compiler.modelbuilder.toolcontext.opt_invocation_metrics.value then add("count_invoke_by_tables++;")
+
+		assert arguments.length == mmethod.intro.msignature.arity + 1 else debug("Invalid arity for {mmethod}. {arguments.length} arguments given.")
+		var recv = arguments.first
+
+		var res0 = before_send(mmethod, arguments)
+
+		var res: nullable RuntimeVariable
+		var msignature = mmethod.intro.msignature.resolve_for(mmethod.intro.mclassdef.bound_mtype, mmethod.intro.mclassdef.bound_mtype, mmethod.intro.mclassdef.mmodule, true)
+		var ret = msignature.return_mtype
+		if mmethod.is_new then
+			ret = arguments.first.mtype
+			res = self.new_var(ret)
+		else if ret == null then
+			res = null
+		else
+			res = self.new_var(ret)
+		end
+
+		var s = new FlatBuffer
+		var ss = new FlatBuffer
+
+		s.append("val*")
+		ss.append("{recv}")
+		for i in [0..msignature.arity[ do
+			var a = arguments[i+1]
+			var t = msignature.mparameters[i].mtype
+			if i == msignature.vararg_rank then
+				t = arguments[i+1].mcasttype
+			end
+			s.append(", {t.ctype}")
+			a = self.autobox(a, t)
+			ss.append(", {a}")
+		end
+
 
 		var r
 		if ret == null then r = "void" else r = ret.ctype
@@ -1109,15 +1108,21 @@ class SeparateCompilerVisitor
 			self.add("{call};")
 		end
 
-		if maybenull then
-			self.add("\}")
+		if res0 != null then
+			assert res != null
+			assign(res0,res)
+			res = res0
 		end
 
+		self.add("\}") # closes the null case
+
 		return res
 	end
 
 	redef fun call(mmethoddef, recvtype, arguments)
 	do
+		assert arguments.length == mmethoddef.msignature.arity + 1 else debug("Invalid arity for {mmethoddef}. {arguments.length} arguments given.")
+
 		var res: nullable RuntimeVariable
 		var ret = mmethoddef.msignature.return_mtype
 		if mmethoddef.mproperty.is_new then
@@ -1130,28 +1135,31 @@ class SeparateCompilerVisitor
 			res = self.new_var(ret)
 		end
 
-		if self.compiler.modelbuilder.mpropdef2npropdef.has_key(mmethoddef) and
-		self.compiler.modelbuilder.mpropdef2npropdef[mmethoddef] isa AInternMethPropdef and
-		not compiler.modelbuilder.toolcontext.opt_no_inline_intern.value then
+		if (mmethoddef.is_intern and not compiler.modelbuilder.toolcontext.opt_no_inline_intern.value) or
+			(compiler.modelbuilder.toolcontext.opt_inline_some_methods.value and mmethoddef.can_inline(self)) then
+			compiler.modelbuilder.nb_invok_by_inline += 1
+			if compiler.modelbuilder.toolcontext.opt_invocation_metrics.value then add("count_invoke_by_inline++;")
 			var frame = new Frame(self, mmethoddef, recvtype, arguments)
 			frame.returnlabel = self.get_name("RET_LABEL")
 			frame.returnvar = res
 			var old_frame = self.frame
 			self.frame = frame
-			self.add("\{ /* Inline {mmethoddef} ({arguments.join(",")}) */")
+			self.add("\{ /* Inline {mmethoddef} ({arguments.join(",")}) on {arguments.first.inspect} */")
 			mmethoddef.compile_inside_to_c(self, arguments)
 			self.add("{frame.returnlabel.as(not null)}:(void)0;")
 			self.add("\}")
 			self.frame = old_frame
 			return res
 		end
+		compiler.modelbuilder.nb_invok_by_direct += 1
+		if compiler.modelbuilder.toolcontext.opt_invocation_metrics.value then add("count_invoke_by_direct++;")
 
 		# Autobox arguments
 		self.adapt_signature(mmethoddef, arguments)
 
 		self.require_declaration(mmethoddef.c_name)
 		if res == null then
-			self.add("{mmethoddef.c_name}({arguments.join(", ")});")
+			self.add("{mmethoddef.c_name}({arguments.join(", ")}); /* Direct call {mmethoddef} on {arguments.first.inspect}*/")
 			return null
 		else
 			self.add("{res} = {mmethoddef.c_name}({arguments.join(", ")});")
@@ -1231,6 +1239,11 @@ class SeparateCompilerVisitor
 		var intromclassdef = a.intro.mclassdef
 		ret = ret.resolve_for(intromclassdef.bound_mtype, intromclassdef.bound_mtype, intromclassdef.mmodule, true)
 
+		if self.compiler.modelbuilder.toolcontext.opt_isset_checks_metrics.value then
+			self.compiler.attr_read_count += 1
+			self.add("count_attr_reads++;")
+		end
+
 		self.require_declaration(a.const_color)
 		if self.compiler.modelbuilder.toolcontext.opt_no_union_attribute.value then
 			# Get the attribute or a box (ie. always a val*)
@@ -1241,10 +1254,15 @@ class SeparateCompilerVisitor
 			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) \{")
+			if not ret isa MNullableType and not self.compiler.modelbuilder.toolcontext.opt_no_check_attr_isset.value then
+				self.add("if (unlikely({res} == NULL)) \{")
 				self.add_abort("Uninitialized attribute {a.name}")
 				self.add("\}")
+
+				if self.compiler.modelbuilder.toolcontext.opt_isset_checks_metrics.value then
+					self.compiler.isset_checks_count += 1
+					self.add("count_isset_checks++;")
+				end
 			end
 
 			# Return the attribute or its unboxed version
@@ -1255,10 +1273,14 @@ class SeparateCompilerVisitor
 			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) \{")
+			if ret.ctype == "val*" and not ret isa MNullableType and not self.compiler.modelbuilder.toolcontext.opt_no_check_attr_isset.value then
+				self.add("if (unlikely({res} == NULL)) \{")
 				self.add_abort("Uninitialized attribute {a.name}")
 				self.add("\}")
+				if self.compiler.modelbuilder.toolcontext.opt_isset_checks_metrics.value then
+					self.compiler.isset_checks_count += 1
+					self.add("count_isset_checks++;")
+				end
 			end
 
 			return res
@@ -1285,7 +1307,7 @@ class SeparateCompilerVisitor
 				# The attribute is primitive, thus we store it in a box
 				# The trick is to create the box the first time then resuse the box
 				self.add("if ({attr} != NULL) \{")
-				self.add("((struct instance_{mtype.c_name}*){attr})->value = {value}; /* {a} on {recv.inspect} */")
+				self.add("((struct instance_{mtype.c_instance_name}*){attr})->value = {value}; /* {a} on {recv.inspect} */")
 				self.add("\} else \{")
 				value = self.autobox(value, self.object_type.as_nullable)
 				self.add("{attr} = {value}; /* {a} on {recv.inspect} */")
@@ -1306,7 +1328,7 @@ class SeparateCompilerVisitor
 		self.require_declaration(mtype.const_color)
 		var col = mtype.const_color
 		self.add("if({col} == -1) \{")
-		self.add("fprintf(stderr, \"Resolution of a dead open type: %s\\n\", \"{mtype.to_s.escape_to_c}\");")
+		self.add("PRINT_ERROR(\"Resolution of a dead open type: %s\\n\", \"{mtype.to_s.escape_to_c}\");")
 		self.add_abort("open type dead")
 		self.add("\}")
 	end
@@ -1319,7 +1341,7 @@ class SeparateCompilerVisitor
 		add_abort("cast type null")
 		add("\}")
 		add("if({t}->id == -1 || {t}->color == -1) \{")
-		add("fprintf(stderr, \"Try to cast on a dead cast type: %s\\n\", {t}->name);")
+		add("PRINT_ERROR(\"Try to cast on a dead cast type: %s\\n\", {t}->name);")
 		add_abort("cast type dead")
 		add("\}")
 	end
@@ -1334,11 +1356,7 @@ class SeparateCompilerVisitor
 			var recv = self.frame.arguments.first
 			var recv_type_info = self.type_info(recv)
 			self.require_declaration(mtype.const_color)
-			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}({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}({recv_type_info}->resolution_table->types[{mtype.const_color}])", mtype)
-			end
+			return self.new_expr("NEW_{mtype.mclass.c_name}({recv_type_info}->resolution_table->types[{mtype.const_color}])", mtype)
 		end
 		compiler.undead_types.add(mtype)
 		self.require_declaration("type_{mtype.c_name}")
@@ -1385,11 +1403,7 @@ class SeparateCompilerVisitor
 			hardening_live_open_type(mtype)
 			link_unresolved_type(self.frame.mpropdef.mclassdef, mtype)
 			self.require_declaration(mtype.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}->resolution_table->types[HASH({recv_type_info}->resolution_table->mask, {mtype.const_color})];")
-			else
-				self.add("{type_struct} = {recv_type_info}->resolution_table->types[{mtype.const_color}];")
-			end
+			self.add("{type_struct} = {recv_type_info}->resolution_table->types[{mtype.const_color}];")
 			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}++;")
@@ -1414,7 +1428,7 @@ class SeparateCompilerVisitor
 				self.add("count_type_test_resolved_{tag}++;")
 			end
 		else
-			self.add("printf(\"NOT YET IMPLEMENTED: type_test(%s, {mtype}).\\n\", \"{value.inspect}\"); show_backtrace(1);")
+			self.add("PRINT_ERROR(\"NOT YET IMPLEMENTED: type_test(%s, {mtype}).\\n\", \"{value.inspect}\"); show_backtrace(1);")
 		end
 
 		# check color is in table
@@ -1424,9 +1438,6 @@ class SeparateCompilerVisitor
 			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 \{")
@@ -1553,12 +1564,12 @@ class SeparateCompilerVisitor
 			end
 		end
 		if primitive != null then
-			test.add("((struct instance_{primitive.c_name}*){value1})->value == ((struct instance_{primitive.c_name}*){value2})->value")
+			test.add("((struct instance_{primitive.c_instance_name}*){value1})->value == ((struct instance_{primitive.c_instance_name}*){value2})->value")
 		else if can_be_primitive(value1) and can_be_primitive(value2) then
 			test.add("{value1}->class == {value2}->class")
 			var s = new Array[String]
 			for t, v in self.compiler.box_kinds do
-				s.add "({value1}->class->box_kind == {v} && ((struct instance_{t.c_name}*){value1})->value == ((struct instance_{t.c_name}*){value2})->value)"
+				s.add "({value1}->class->box_kind == {v} && ((struct instance_{t.c_instance_name}*){value1})->value == ((struct instance_{t.c_instance_name}*){value2})->value)"
 			end
 			test.add("({s.join(" || ")})")
 		else
@@ -1571,8 +1582,7 @@ class SeparateCompilerVisitor
 
 	fun can_be_primitive(value: RuntimeVariable): Bool
 	do
-		var t = value.mcasttype
-		if t isa MNullableType then t = t.mtype
+		var t = value.mcasttype.as_notnullable
 		if not t isa MClassType then return false
 		var k = t.mclass.kind
 		return k == interface_kind or t.ctype != "val*"
@@ -1602,7 +1612,7 @@ class SeparateCompilerVisitor
 		return res
 	end
 
-	fun native_array_instance(elttype: MType, length: RuntimeVariable): RuntimeVariable
+	redef fun native_array_instance(elttype: MType, length: RuntimeVariable): RuntimeVariable
 	do
 		var mtype = self.get_class("NativeArray").get_mtype([elttype])
 		self.require_declaration("NEW_{mtype.mclass.c_name}")
@@ -1614,11 +1624,7 @@ class SeparateCompilerVisitor
 			var recv = self.frame.arguments.first
 			var recv_type_info = self.type_info(recv)
 			self.require_declaration(mtype.const_color)
-			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}, {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}, {recv_type_info}->resolution_table->types[{mtype.const_color}])", mtype)
-			end
+			return self.new_expr("NEW_{mtype.mclass.c_name}({length}, {recv_type_info}->resolution_table->types[{mtype.const_color}])", mtype)
 		end
 		compiler.undead_types.add(mtype)
 		self.require_declaration("type_{mtype.c_name}")
@@ -1629,16 +1635,19 @@ class SeparateCompilerVisitor
 	do
 		var elttype = arguments.first.mtype
 		var nclass = self.get_class("NativeArray")
-		var recv = "((struct instance_{nclass.c_name}*){arguments[0]})->values"
+		var recv = "((struct instance_{nclass.c_instance_name}*){arguments[0]})->values"
 		if pname == "[]" then
 			self.ret(self.new_expr("{recv}[{arguments[1]}]", ret_type.as(not null)))
 			return
 		else if pname == "[]=" then
 			self.add("{recv}[{arguments[1]}]={arguments[2]};")
 			return
+		else if pname == "length" then
+			self.ret(self.new_expr("((struct instance_{nclass.c_instance_name}*){arguments[0]})->length", ret_type.as(not null)))
+			return
 		else if pname == "copy_to" then
-			var recv1 = "((struct instance_{nclass.c_name}*){arguments[1]})->values"
-			self.add("memcpy({recv1}, {recv}, {arguments[2]}*sizeof({elttype.ctype}));")
+			var recv1 = "((struct instance_{nclass.c_instance_name}*){arguments[1]})->values"
+			self.add("memmove({recv1}, {recv}, {arguments[2]}*sizeof({elttype.ctype}));")
 			return
 		end
 	end
@@ -1706,8 +1715,8 @@ class SeparateRuntimeFunction
 
 		var msignature = mmethoddef.msignature.resolve_for(mmethoddef.mclassdef.bound_mtype, mmethoddef.mclassdef.bound_mtype, mmethoddef.mclassdef.mmodule, true)
 
-		var sig = new Buffer
-		var comment = new Buffer
+		var sig = new FlatBuffer
+		var comment = new FlatBuffer
 		var ret = msignature.return_mtype
 		if ret != null then
 			sig.append("{ret.ctype} ")
@@ -1779,8 +1788,8 @@ class VirtualRuntimeFunction
 		var frame = new Frame(v, mmethoddef, recv, arguments)
 		v.frame = frame
 
-		var sig = new Buffer
-		var comment = new Buffer
+		var sig = new FlatBuffer
+		var comment = new FlatBuffer
 
 		# Because the function is virtual, the signature must match the one of the original class
 		var intromclassdef = self.mmethoddef.mproperty.intro.mclassdef
@@ -1842,12 +1851,33 @@ end
 
 redef class MType
 	fun const_color: String do return "COLOR_{c_name}"
+
+	# C name of the instance type to use
+	fun c_instance_name: String do return c_name
 end
 
+redef class MClassType
+	redef fun c_instance_name do return mclass.c_instance_name
+end
+
+redef class MClass
+	# Extern classes use the C instance of kernel::Pointer
+	fun c_instance_name: String
+	do
+		if kind == extern_kind then
+			return "kernel__Pointer"
+		else return c_name
+	end
+end
+
+interface PropertyLayoutElement end
+
 redef class MProperty
+	super PropertyLayoutElement
 	fun const_color: String do return "COLOR_{c_name}"
 end
 
 redef class MPropDef
+	super PropertyLayoutElement
 	fun const_color: String do return "COLOR_{c_name}"
 end