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

diff --git a/src/compiler/separate_compiler.nit b/src/compiler/separate_compiler.nit
index dab4a79..18ee159 100644
--- a/src/compiler/separate_compiler.nit
+++ b/src/compiler/separate_compiler.nit
@@ -252,7 +252,7 @@ class SeparateCompiler
 	do
 		# Collect all bas box class
 		# FIXME: this is not completely fine with a separate compilation scheme
-		for classname in ["Int", "Bool", "Char", "Float", "NativeString", "Pointer"] do
+		for classname in ["Int", "Bool", "Byte", "Char", "Float", "NativeString", "Pointer"] do
 			var classes = self.mainmodule.model.get_mclasses_by_name(classname)
 			if classes == null then continue
 			assert classes.length == 1 else print classes.join(", ")
@@ -458,14 +458,14 @@ class SeparateCompiler
 
 		var mtypes_by_class = new MultiHashMap[MClass, MType]
 		for e in mtypes do
-			var c = e.as_notnullable.as(MClassType).mclass
+			var c = e.undecorate.as(MClassType).mclass
 			mtypes_by_class[c].add(e)
 			poset.add_node(e)
 		end
 
 		var casttypes_by_class = new MultiHashMap[MClass, MType]
 		for e in cast_types do
-			var c = e.as_notnullable.as(MClassType).mclass
+			var c = e.undecorate.as(MClassType).mclass
 			casttypes_by_class[c].add(e)
 			poset.add_node(e)
 		end
@@ -510,7 +510,7 @@ class SeparateCompiler
 		# Group cast_type by their classes
 		var bucklets = new HashMap[MClass, Set[MType]]
 		for e in cast_types do
-			var c = e.as_notnullable.as(MClassType).mclass
+			var c = e.undecorate.as(MClassType).mclass
 			if not bucklets.has_key(c) then
 				bucklets[c] = new HashSet[MType]
 			end
@@ -625,6 +625,7 @@ class SeparateCompiler
 		for cd in mmodule.mclassdefs do
 			for pd in cd.mpropdefs do
 				if not pd isa MMethodDef then continue
+				if pd.msignature == null then continue # Skip broken method
 				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}"
@@ -742,7 +743,7 @@ class SeparateCompiler
 
 		# resolution table (for receiver)
 		if is_live then
-			var mclass_type = mtype.as_notnullable
+			var mclass_type = mtype.undecorate
 			assert mclass_type isa MClassType
 			if resolution_tables[mclass_type].is_empty then
 				v.add_decl("NULL, /*NO RESOLUTIONS*/")
@@ -768,14 +769,15 @@ class SeparateCompiler
 			end
 			v.add_decl("\},")
 		else
-			v.add_decl("0, \{\}, /*DEAD TYPE*/")
+			# Use -1 to indicate dead type, the info is used by --hardening
+			v.add_decl("-1, \{\}, /*DEAD TYPE*/")
 		end
 		v.add_decl("\};")
 	end
 
 	fun compile_type_resolution_table(mtype: MType) do
 
-		var mclass_type = mtype.as_notnullable.as(MClassType)
+		var mclass_type = mtype.undecorate.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};")
@@ -817,12 +819,15 @@ class SeparateCompiler
 		var v = new_visitor
 
 		var rta = runtime_type_analysis
-		var is_dead = rta != null and not rta.live_classes.has(mclass) and not mtype.is_c_primitive and mclass.name != "NativeArray" and mclass.name != "Pointer"
+		var is_dead = rta != null and not rta.live_classes.has(mclass)
+		# While the class may be dead, some part of separately compiled code may use symbols associated to the class, so
+		# in order to compile and link correctly the C code, these symbols should be declared and defined.
+		var need_corpse = is_dead and mtype.is_c_primitive or mclass.kind == extern_kind or mclass.kind == enum_kind
 
-		v.add_decl("/* runtime class {c_name} */")
+		v.add_decl("/* runtime class {c_name}: {mclass.full_name} (dead={is_dead}; need_corpse={need_corpse})*/")
 
 		# Build class vft
-		if not is_dead then
+		if not is_dead or need_corpse then
 			self.provide_declaration("class_{c_name}", "extern const struct class class_{c_name};")
 			v.add_decl("const struct class class_{c_name} = \{")
 			v.add_decl("{self.box_kind_of(mclass)}, /* box_kind */")
@@ -859,7 +864,8 @@ class SeparateCompiler
 			self.header.add_decl("{mtype.ctype_extern} value;")
 			self.header.add_decl("\};")
 
-			if not rta.live_types.has(mtype) and mtype.mclass.name != "Pointer" then return
+			# Pointer is needed by extern types, live or not
+			if is_dead and mtype.mclass.name != "Pointer" then return
 
 			#Build BOX
 			self.provide_declaration("BOX_{c_name}", "val* BOX_{c_name}({mtype.ctype_extern});")
@@ -875,6 +881,7 @@ class SeparateCompiler
 			v.add("return (val*)res;")
 			v.add("\}")
 
+			# A Pointer class also need its constructor
 			if mtype.mclass.name != "Pointer" then return
 
 			v = new_visitor
@@ -929,7 +936,7 @@ class SeparateCompiler
 			var pointer_type = mainmodule.pointer_type
 
 			self.provide_declaration("NEW_{c_name}", "{mtype.ctype} NEW_{c_name}(const struct type* type);")
-			v.add_decl("/* allocate {mtype} */")
+			v.add_decl("/* allocate extern {mtype} */")
 			v.add_decl("{mtype.ctype} NEW_{c_name}(const struct type* type) \{")
 			if is_dead then
 				v.add_abort("{mclass} is DEAD")
@@ -1036,7 +1043,7 @@ class SeparateCompiler
 		v.add("if({t} == NULL) \{")
 		v.add_abort("type null")
 		v.add("\}")
-		v.add("if({t}->table_size == 0) \{")
+		v.add("if({t}->table_size < 0) \{")
 		v.add("PRINT_ERROR(\"Insantiation of a dead type: %s\\n\", {t}->name);")
 		v.add_abort("type dead")
 		v.add("\}")
@@ -1192,7 +1199,7 @@ class SeparateCompilerVisitor
 				if mtype.name == "Int" then
 					return self.new_expr("(long)({value})>>2", mtype)
 				else if mtype.name == "Char" then
-					return self.new_expr("(char)((long)({value})>>2)", mtype)
+					return self.new_expr("(uint32_t)((long)({value})>>2)", mtype)
 				else if mtype.name == "Bool" then
 					return self.new_expr("(short int)((long)({value})>>2)", mtype)
 				else
@@ -1217,11 +1224,6 @@ class SeparateCompilerVisitor
 				valtype = compiler.mainmodule.pointer_type
 			end
 			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("PRINT_ERROR(\"Dead code executed!\\n\"); fatal_exit(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
@@ -1257,11 +1259,7 @@ class SeparateCompilerVisitor
 		   mtype.mclass.name != "NativeString" then
 			var valtype = compiler.mainmodule.pointer_type
 			var res = self.new_var(mtype)
-			if compiler.runtime_type_analysis != null and not compiler.runtime_type_analysis.live_types.has(value.mtype.as(MClassType)) then
-				self.add("/*no boxing of {value.mtype}: {value.mtype} is not live! */")
-				self.add("PRINT_ERROR(\"Dead code executed!\\n\"); fatal_exit(1);")
-				return res
-			end
+			compiler.undead_types.add(mtype)
 			self.require_declaration("BOX_{valtype.c_name}")
 			self.add("{res} = BOX_{valtype.c_name}({value}); /* boxing {value.mtype} */")
 			self.require_declaration("type_{mtype.c_name}")
@@ -1436,13 +1434,14 @@ class SeparateCompilerVisitor
 		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 runtime_function = mmethod.intro.virtual_runtime_function
 		var msignature = runtime_function.called_signature
 
+		adapt_signature(mmethod.intro, arguments)
+
 		var res: nullable RuntimeVariable
 		var ret = msignature.return_mtype
 		if ret == null then
@@ -1451,18 +1450,7 @@ class SeparateCompilerVisitor
 			res = self.new_var(ret)
 		end
 
-		var ss = new FlatBuffer
-
-		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
-			a = self.autobox(a, t)
-			ss.append(", {a}")
-		end
+		var ss = arguments.join(", ")
 
 		var const_color = mentity.const_color
 		var ress
@@ -2006,7 +1994,7 @@ class SeparateCompilerVisitor
 
 	fun can_be_primitive(value: RuntimeVariable): Bool
 	do
-		var t = value.mcasttype.as_notnullable
+		var t = value.mcasttype.undecorate
 		if not t isa MClassType then return false
 		var k = t.mclass.kind
 		return k == interface_kind or t.is_c_primitive
@@ -2042,6 +2030,7 @@ class SeparateCompilerVisitor
 		self.require_declaration("NEW_{mtype.mclass.c_name}")
 		assert mtype isa MGenericType
 		var compiler = self.compiler
+		length = autobox(length, compiler.mainmodule.int_type)
 		if mtype.need_anchor then
 			hardening_live_open_type(mtype)
 			link_unresolved_type(self.frame.mpropdef.mclassdef, mtype)
@@ -2216,13 +2205,18 @@ class SeparateRuntimeFunction
 	# The C type for the function pointer.
 	var c_funptrtype: String is lazy do return "{c_ret}(*){c_sig}"
 
-	# The arguments, as generated by `compile_to_c`
-	private var arguments: Array[RuntimeVariable] is noinit
-
 	redef fun compile_to_c(compiler)
 	do
 		var mmethoddef = self.mmethoddef
 
+		var sig = "{c_ret} {c_name}{c_sig}"
+		compiler.provide_declaration(self.c_name, "{sig} __attribute__((weak));")
+
+		var rta = compiler.as(SeparateCompiler).runtime_type_analysis
+		if rta != null and not rta.live_mmodules.has(mmethoddef.mclassdef.mmodule) then
+			return
+		end
+
 		var recv = self.mmethoddef.mclassdef.bound_mtype
 		var v = compiler.new_visitor
 		var selfvar = new RuntimeVariable("self", called_recv, recv)
@@ -2233,12 +2227,7 @@ class SeparateRuntimeFunction
 		var msignature = called_signature
 		var ret = called_signature.return_mtype
 
-		var sig = new FlatBuffer
 		var comment = new FlatBuffer
-		sig.append(c_ret)
-		sig.append(" ")
-		sig.append(self.c_name)
-		sig.append(c_sig)
 		comment.append("({selfvar}: {selfvar.mtype}")
 		arguments.add(selfvar)
 		for i in [0..msignature.arity[ do
@@ -2254,8 +2243,6 @@ class SeparateRuntimeFunction
 		if ret != null then
 			comment.append(": {ret}")
 		end
-		compiler.provide_declaration(self.c_name, "{sig};")
-		self.arguments = arguments.to_a
 
 		v.add_decl("/* method {self} for {comment} */")
 		v.add_decl("{sig} \{")
@@ -2288,8 +2275,10 @@ class SeparateRuntimeFunction
 	fun compile_trampolines(compiler: SeparateCompiler)
 	do
 		var recv = self.mmethoddef.mclassdef.bound_mtype
-		var selfvar = arguments.first
+		var selfvar = new RuntimeVariable("self", called_recv, recv)
 		var ret = called_signature.return_mtype
+		var arguments = ["self"]
+		for i in [0..called_signature.arity[ do arguments.add "p{i}"
 
 		if mmethoddef.is_intro and not recv.is_c_primitive then
 			var m = mmethoddef.mproperty