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

diff --git a/src/abstract_compiler.nit b/src/abstract_compiler.nit
index cf5e064..e5cba5c 100644
--- a/src/abstract_compiler.nit
+++ b/src/abstract_compiler.nit
@@ -20,7 +20,8 @@ module abstract_compiler
 import literal
 import typing
 import auto_super_init
-import frontend
+import platform
+import c_tools
 
 # Add compiling options
 redef class ToolContext
@@ -32,14 +33,16 @@ redef class ToolContext
 	var opt_cc_path: OptionArray = new OptionArray("Set include path for C header files (may be used more than once)", "--cc-path")
 	# --make-flags
 	var opt_make_flags: OptionString = new OptionString("Additional options to make", "--make-flags")
+	# --compile-dir
+	var opt_compile_dir: OptionString = new OptionString("Directory used to generate temporary files", "--compile-dir")
 	# --hardening
 	var opt_hardening: OptionBool = new OptionBool("Generate contracts in the C code against bugs in the compiler", "--hardening")
 	# --no-shortcut-range
 	var opt_no_shortcut_range: OptionBool = new OptionBool("Always insantiate a range and its iterator on 'for' loops", "--no-shortcut-range")
 	# --no-check-covariance
 	var opt_no_check_covariance: OptionBool = new OptionBool("Disable type tests of covariant parameters (dangerous)", "--no-check-covariance")
-	# --no-check-initialization
-	var opt_no_check_initialization: OptionBool = new OptionBool("Disable isset tests at the end of constructors (dangerous)", "--no-check-initialization")
+	# --no-check-attr-isset
+	var opt_no_check_attr_isset: OptionBool = new OptionBool("Disable isset tests before each attribute access (dangerous)", "--no-check-attr-isset")
 	# --no-check-assert
 	var opt_no_check_assert: OptionBool = new OptionBool("Disable the evaluation of explicit 'assert' and 'as' (dangerous)", "--no-check-assert")
 	# --no-check-autocast
@@ -48,39 +51,97 @@ redef class ToolContext
 	var opt_no_check_other: OptionBool = new OptionBool("Disable implicit tests: unset attribute, null receiver (dangerous)", "--no-check-other")
 	# --typing-test-metrics
 	var opt_typing_test_metrics: OptionBool = new OptionBool("Enable static and dynamic count of all type tests", "--typing-test-metrics")
+	# --invocation-metrics
+	var opt_invocation_metrics: OptionBool = new OptionBool("Enable static and dynamic count of all method invocations", "--invocation-metrics")
+	# --isset-checks-metrics
+	var opt_isset_checks_metrics: OptionBool = new OptionBool("Enable static and dynamic count of isset checks before attributes access", "--isset-checks-metrics")
+	# --stacktrace
+	var opt_stacktrace: OptionString = new OptionString("Control the generation of stack traces", "--stacktrace")
+	# --no-gcc-directives
+	var opt_no_gcc_directive = new OptionArray("Disable a advanced gcc directives for optimization", "--no-gcc-directive")
 
 	redef init
 	do
 		super
-		self.option_context.add_option(self.opt_output, self.opt_no_cc, self.opt_make_flags, self.opt_hardening, self.opt_no_shortcut_range)
-		self.option_context.add_option(self.opt_no_check_covariance, self.opt_no_check_initialization, self.opt_no_check_assert, self.opt_no_check_autocast, self.opt_no_check_other)
-		self.option_context.add_option(self.opt_typing_test_metrics)
+		self.option_context.add_option(self.opt_output, self.opt_no_cc, self.opt_make_flags, self.opt_compile_dir, self.opt_hardening, self.opt_no_shortcut_range)
+		self.option_context.add_option(self.opt_no_check_covariance, self.opt_no_check_attr_isset, self.opt_no_check_assert, self.opt_no_check_autocast, self.opt_no_check_other)
+		self.option_context.add_option(self.opt_typing_test_metrics, self.opt_invocation_metrics, self.opt_isset_checks_metrics)
+		self.option_context.add_option(self.opt_stacktrace)
+		self.option_context.add_option(self.opt_no_gcc_directive)
+	end
+
+	redef fun process_options(args)
+	do
+		super
+
+		var st = opt_stacktrace.value
+		if st == null or st == "none" or st == "libunwind" or st == "nitstack" then
+			# Fine, do nothing
+		else if st == "auto" then
+			# Default just unset
+			opt_stacktrace.value = null
+		else
+			print "Error: unknown value `{st}` for --stacktrace. Use `none`, `libunwind`, `nitstack` or `auto`."
+			exit(1)
+		end
 	end
 end
 
 redef class ModelBuilder
+	# The compilation directory
+	var compile_dir: String
+
+	# Simple indirection to `Toolchain::write_and_make`
+	protected fun write_and_make(compiler: AbstractCompiler)
+	do
+		var platform = compiler.mainmodule.target_platform
+		var toolchain
+		if platform == null then
+			toolchain = new MakefileToolchain(toolcontext)
+		else
+			toolchain = platform.toolchain(toolcontext)
+		end
+		compile_dir = toolchain.compile_dir
+		toolchain.write_and_make compiler
+	end
+end
+
+redef class Platform
+	fun toolchain(toolcontext: ToolContext): Toolchain is abstract
+end
+
+class Toolchain
+	var toolcontext: ToolContext
+
+	fun compile_dir: String
+	do
+		var compile_dir = toolcontext.opt_compile_dir.value
+		if compile_dir == null then compile_dir = ".nit_compile"
+		return compile_dir
+	end
+
+	fun write_and_make(compiler: AbstractCompiler) is abstract
+end
+
+class MakefileToolchain
+	super Toolchain
 	# The list of directories to search for included C headers (-I for C compilers)
 	# The list is initially set with :
 	#   * the toolcontext --cc-path option
 	#   * the NIT_CC_PATH environment variable
-	#   * some heuristics including the NIT_DIR environment variable and the progname of the process
+	#   * `toolcontext.nit_dir`
 	# Path can be added (or removed) by the client
 	var cc_paths = new Array[String]
 
-	redef init(model, toolcontext)
+	protected fun gather_cc_paths
 	do
-		super
-
 		# Look for the the Nit clib path
-		var path_env = "NIT_DIR".environ
-		if not path_env.is_empty then
+		var path_env = toolcontext.nit_dir
+		if path_env != null then
 			var libname = "{path_env}/clib"
 			if libname.file_exists then cc_paths.add(libname)
 		end
 
-		var libname = "{sys.program_name.dirname}/../clib"
-		if libname.file_exists then cc_paths.add(libname.simplify_path)
-
 		if cc_paths.is_empty then
 			toolcontext.error(null, "Cannot determine the nit clib path. define envvar NIT_DIR.")
 		end
@@ -92,12 +153,14 @@ redef class ModelBuilder
 		if not path_env.is_empty then
 			cc_paths.append(path_env.split_with(':'))
 		end
-
 	end
 
-	protected fun write_and_make(compiler: AbstractCompiler)
+	redef fun write_and_make(compiler)
 	do
+		gather_cc_paths
+
 		var mainmodule = compiler.mainmodule
+		var compile_dir = compile_dir
 
 		# Generate the .h and .c files
 		# A single C file regroups many compiled rumtime functions
@@ -105,15 +168,56 @@ redef class ModelBuilder
 		var time0 = get_time
 		self.toolcontext.info("*** WRITING C ***", 1)
 
-		".nit_compile".mkdir
+		compile_dir.mkdir
 
-		var outname = self.toolcontext.opt_output.value
-		if outname == null then
-			outname = "{mainmodule.name}"
+		var cfiles = new Array[String]
+		write_files(compiler, compile_dir, cfiles)
+
+		# Generate the Makefile
+
+		write_makefile(compiler, compile_dir, cfiles)
+
+		var time1 = get_time
+		self.toolcontext.info("*** END WRITING C: {time1-time0} ***", 2)
+
+		# Execute the Makefile
+
+		if self.toolcontext.opt_no_cc.value then return
+
+		time0 = time1
+		self.toolcontext.info("*** COMPILING C ***", 1)
+
+		compile_c_code(compiler, compile_dir)
+
+		time1 = get_time
+		self.toolcontext.info("*** END COMPILING C: {time1-time0} ***", 2)
+	end
+
+	fun write_files(compiler: AbstractCompiler, compile_dir: String, cfiles: Array[String])
+	do
+		if self.toolcontext.opt_stacktrace.value == "nitstack" then compiler.build_c_to_nit_bindings
+
+		# Add gc_choser.h to aditionnal bodies
+		var gc_chooser = new ExternCFile("gc_chooser.c", "-DWITH_LIBGC")
+		compiler.extern_bodies.add(gc_chooser)
+		compiler.files_to_copy.add "{cc_paths.first}/gc_chooser.c"
+		compiler.files_to_copy.add "{cc_paths.first}/gc_chooser.h"
+
+		# FFI
+		var m2m = toolcontext.modelbuilder.mmodule2nmodule
+		for m in compiler.mainmodule.in_importation.greaters do
+			compiler.finalize_ffi_for_module(m)
+		end
+
+		# Copy original .[ch] files to compile_dir
+		for src in compiler.files_to_copy do
+			var basename = src.basename("")
+			var dst = "{compile_dir}/{basename}"
+			src.file_copy_to dst
 		end
 
 		var hfilename = compiler.header.file.name + ".h"
-		var hfilepath = ".nit_compile/{hfilename}"
+		var hfilepath = "{compile_dir}/{hfilename}"
 		var h = new OFStream.open(hfilepath)
 		for l in compiler.header.decl_lines do
 			h.write l
@@ -125,18 +229,22 @@ redef class ModelBuilder
 		end
 		h.close
 
-		var cfiles = new Array[String]
-
 		for f in compiler.files do
 			var i = 0
 			var hfile: nullable OFStream = null
 			var count = 0
-			var cfilename = ".nit_compile/{f.name}.0.h"
-			hfile = new OFStream.open(cfilename)
+			var cfilename = "{f.name}.0.h"
+			var cfilepath = "{compile_dir}/{cfilename}"
+			hfile = new OFStream.open(cfilepath)
 			hfile.write "#include \"{hfilename}\"\n"
 			for key in f.required_declarations do
 				if not compiler.provided_declarations.has_key(key) then
-					print "No provided declaration for {key}"
+					var node = compiler.requirers_of_declarations.get_or_null(key)
+					if node != null then
+						node.debug "No provided declaration for {key}"
+					else
+						print "No provided declaration for {key}"
+					end
 					abort
 				end
 				hfile.write compiler.provided_declarations[key]
@@ -152,10 +260,11 @@ redef class ModelBuilder
 				if file == null or count > 10000  then
 					i += 1
 					if file != null then file.close
-					cfilename = ".nit_compile/{f.name}.{i}.c"
-					self.toolcontext.info("new C source files to compile: {cfilename}", 3)
+					cfilename = "{f.name}.{i}.c"
+					cfilepath = "{compile_dir}/{cfilename}"
+					self.toolcontext.info("new C source files to compile: {cfilepath}", 3)
 					cfiles.add(cfilename)
-					file = new OFStream.open(cfilename)
+					file = new OFStream.open(cfilepath)
 					file.write "#include \"{f.name}.0.h\"\n"
 					count = total_lines
 				end
@@ -172,72 +281,102 @@ redef class ModelBuilder
 		end
 
 		self.toolcontext.info("Total C source files to compile: {cfiles.length}", 2)
+	end
 
-		# Generate the Makefile
+	fun write_makefile(compiler: AbstractCompiler, compile_dir: String, cfiles: Array[String])
+	do
+		var mainmodule = compiler.mainmodule
 
-		var makename = ".nit_compile/{mainmodule.name}.mk"
-		var makefile = new OFStream.open(makename)
+		var outname = self.toolcontext.opt_output.value
+		if outname == null then
+			outname = "{mainmodule.name}"
+		end
+
+		var orig_dir=".." # FIXME only works if `compile_dir` is a subdirectory of cwd
+		var outpath = orig_dir.join_path(outname).simplify_path
+		var makename = "{mainmodule.name}.mk"
+		var makepath = "{compile_dir}/{makename}"
+		var makefile = new OFStream.open(makepath)
 
 		var cc_includes = ""
 		for p in cc_paths do
-			#p = "..".join_path(p)
 			cc_includes += " -I \"" + p + "\""
 		end
-		makefile.write("CC = ccache cc\nCFLAGS = -g -O2\nCINCL = {cc_includes}\nLDFLAGS ?= \nLDLIBS  ?= -lm -lgc\n\n")
-		makefile.write("all: {outname}\n\n")
+
+		var linker_options = new HashSet[String]
+		var m2m = toolcontext.modelbuilder.mmodule2nmodule
+		for m in mainmodule.in_importation.greaters do
+			var libs = m.collect_linker_libs
+			if libs != null then linker_options.add_all(libs)
+		end
+
+		var ost = toolcontext.opt_stacktrace.value
+		if ost == "libunwind" or ost == "nitstack" then linker_options.add("-lunwind")
+
+		makefile.write("CC = ccache cc\nCFLAGS = -g -O2\nCINCL = {cc_includes}\nLDFLAGS ?= \nLDLIBS  ?= -lm -lgc {linker_options.join(" ")}\n\n")
+		makefile.write("all: {outpath}\n\n")
 
 		var ofiles = new Array[String]
+		var dep_rules = new Array[String]
 		# Compile each generated file
 		for f in cfiles do
 			var o = f.strip_extension(".c") + ".o"
-			makefile.write("{o}: {f}\n\t$(CC) $(CFLAGS) $(CINCL) -D NONITCNI -c -o {o} {f}\n\n")
+			makefile.write("{o}: {f}\n\t$(CC) $(CFLAGS) $(CINCL) -c -o {o} {f}\n\n")
 			ofiles.add(o)
+			dep_rules.add(o)
 		end
 
-		# Add gc_choser.h to aditionnal bodies
-		var gc_chooser = new ExternCFile("{cc_paths.first}/gc_chooser.c", "-DWITH_LIBGC")
-		compiler.extern_bodies.add(gc_chooser)
+		var java_files = new Array[ExternFile]
 
 		# Compile each required extern body into a specific .o
 		for f in compiler.extern_bodies do
-			var basename = f.filename.basename(".c")
-			var o = ".nit_compile/{basename}.extern.o"
-			makefile.write("{o}: {f.filename}\n\t$(CC) $(CFLAGS) -D NONITCNI {f.cflags} -c -o {o} {f.filename}\n\n")
-			ofiles.add(o)
+			var o = f.makefile_rule_name
+			var ff = f.filename.basename("")
+			makefile.write("{o}: {ff}\n")
+			makefile.write("\t{f.makefile_rule_content}\n\n")
+			dep_rules.add(f.makefile_rule_name)
+
+			if f.compiles_to_o_file then ofiles.add(o)
+			if f.add_to_jar then java_files.add(f)
+		end
+		
+		if not java_files.is_empty then
+			var jar_file = "{outpath}.jar"
+
+			var class_files_array = new Array[String]
+			for f in java_files do class_files_array.add(f.makefile_rule_name)
+			var class_files = class_files_array.join(" ")
+
+			makefile.write("{jar_file}: {class_files}\n")
+			makefile.write("\tjar cf {jar_file} {class_files}\n\n")
+			dep_rules.add jar_file
 		end
 
 		# Link edition
-		makefile.write("{outname}: {ofiles.join(" ")}\n\t$(CC) $(LDFLAGS) -o {outname} {ofiles.join(" ")} $(LDLIBS)\n\n")
+		makefile.write("{outpath}: {dep_rules.join(" ")}\n\t$(CC) $(LDFLAGS) -o {outpath} {ofiles.join(" ")} $(LDLIBS)\n\n")
 		# Clean
 		makefile.write("clean:\n\trm {ofiles.join(" ")} 2>/dev/null\n\n")
 		makefile.close
-		self.toolcontext.info("Generated makefile: {makename}", 2)
-
-		var time1 = get_time
-		self.toolcontext.info("*** END WRITING C: {time1-time0} ***", 2)
-
-		# Execute the Makefile
+		self.toolcontext.info("Generated makefile: {makepath}", 2)
+	end
 
-		if self.toolcontext.opt_no_cc.value then return
+	fun compile_c_code(compiler: AbstractCompiler, compile_dir: String)
+	do
+		var makename = "{compiler.mainmodule.name}.mk" # FIXME duplicated from write_makefile
 
-		time0 = time1
-		self.toolcontext.info("*** COMPILING C ***", 1)
 		var makeflags = self.toolcontext.opt_make_flags.value
 		if makeflags == null then makeflags = ""
-		self.toolcontext.info("make -B -f {makename} -j 4 {makeflags}", 2)
+		self.toolcontext.info("make -B -C {compile_dir} -f {makename} -j 4 {makeflags}", 2)
 
 		var res
 		if self.toolcontext.verbose_level >= 3 then
-			res = sys.system("make -B -f {makename} -j 4 {makeflags} 2>&1")
+			res = sys.system("make -B -C {compile_dir} -f {makename} -j 4 {makeflags} 2>&1")
 		else
-			res = sys.system("make -B -f {makename} -j 4 {makeflags} 2>&1 >/dev/null")
+			res = sys.system("make -B -C {compile_dir} -f {makename} -j 4 {makeflags} 2>&1 >/dev/null")
 		end
 		if res != 0 then
 			toolcontext.error(null, "make failed! Error code: {res}.")
 		end
-
-		time1 = get_time
-		self.toolcontext.info("*** END COMPILING C: {time1-time0} ***", 2)
 	end
 end
 
@@ -245,6 +384,9 @@ end
 abstract class AbstractCompiler
 	type VISITOR: AbstractCompilerVisitor
 
+	# Table corresponding c_names to nit names (methods)
+	var names = new HashMap[String, String]
+
 	# The main module of the program currently compiled
 	# Is assigned during the separate compilation
 	var mainmodule: MModule writable
@@ -295,26 +437,97 @@ abstract class AbstractCompiler
 
 	private var provided_declarations = new HashMap[String, String]
 
+	private var requirers_of_declarations = new HashMap[String, ANode]
+
+	# Builds the .c and .h files to be used when generating a Stack Trace
+	# Binds the generated C function names to Nit function names
+	fun build_c_to_nit_bindings
+	do
+		var compile_dir = modelbuilder.compile_dir
+
+		var stream = new OFStream.open("{compile_dir}/c_functions_hash.c")
+		stream.write("#include <string.h>\n")
+		stream.write("#include <stdlib.h>\n")
+		stream.write("#include \"c_functions_hash.h\"\n")
+		stream.write("typedef struct C_Nit_Names\{char* name; char* nit_name;\}C_Nit_Names;\n")
+		stream.write("const char* get_nit_name(register const char* procproc, register unsigned int len)\{\n")
+		stream.write("char* procname = malloc(len+1);")
+		stream.write("memcpy(procname, procproc, len);")
+		stream.write("procname[len] = '\\0';")
+		stream.write("static const C_Nit_Names map[{names.length}] = \{\n")
+		for i in names.keys do
+			stream.write("\{\"")
+			stream.write(i)
+			stream.write("\",\"")
+			stream.write(names[i])
+			stream.write("\"\},\n")
+		end
+		stream.write("\};\n")
+		stream.write("int i;")
+		stream.write("for(i = 0; i < {names.length}; i++)\{")
+		stream.write("if(strcmp(procname,map[i].name) == 0)\{")
+		stream.write("free(procname);")
+		stream.write("return map[i].nit_name;")
+		stream.write("\}")
+		stream.write("\}")
+		stream.write("free(procname);")
+		stream.write("return NULL;")
+		stream.write("\}\n")
+		stream.close
+
+		stream = new OFStream.open("{compile_dir}/c_functions_hash.h")
+		stream.write("const char* get_nit_name(register const char* procname, register unsigned int len);\n")
+		stream.close
+
+		extern_bodies.add(new ExternCFile("{compile_dir}/c_functions_hash.c", ""))
+	end
+
 	# Compile C headers
 	# This method call compile_header_strucs method that has to be refined
 	fun compile_header do
 		var v = self.header
+		var toolctx = modelbuilder.toolcontext
 		self.header.add_decl("#include <stdlib.h>")
 		self.header.add_decl("#include <stdio.h>")
 		self.header.add_decl("#include <string.h>")
-		self.header.add_decl("#include <gc_chooser.h>")
+		self.header.add_decl("#include \"gc_chooser.h\"")
 
 		compile_header_structs
+		compile_nitni_structs
+
+		var gccd_disable = modelbuilder.toolcontext.opt_no_gcc_directive.value
+		if gccd_disable.has("noreturn") or gccd_disable.has("all") then
+			# Signal handler function prototype
+			self.header.add_decl("void show_backtrace(int);")
+		else
+			self.header.add_decl("void show_backtrace(int) __attribute__ ((noreturn));")
+		end
+
+		if gccd_disable.has("likely") or gccd_disable.has("all") then
+			self.header.add_decl("#define likely(x)       (x)")
+			self.header.add_decl("#define unlikely(x)     (x)")
+		else if gccd_disable.has("correct-likely") then
+			# invert the `likely` definition
+			# Used by masochists to bench the worst case
+			self.header.add_decl("#define likely(x)       __builtin_expect((x),0)")
+			self.header.add_decl("#define unlikely(x)     __builtin_expect((x),1)")
+		else
+			self.header.add_decl("#define likely(x)       __builtin_expect((x),1)")
+			self.header.add_decl("#define unlikely(x)     __builtin_expect((x),0)")
+		end
 
-		# Global variable used by the legacy native interface
+		# Global variable used by intern methods
 		self.header.add_decl("extern int glob_argc;")
 		self.header.add_decl("extern char **glob_argv;")
 		self.header.add_decl("extern val *glob_sys;")
 	end
 
-	# Declaration of structures the live Nit types
+	# Declaration of structures for live Nit types
 	protected fun compile_header_structs is abstract
 
+	# Declaration of structures for nitni undelying the FFI
+	protected fun compile_nitni_structs is abstract
+
 	# Generate the main C function.
 	# This function:
 	# 	* allocate the Sys object if it exists
@@ -323,6 +536,21 @@ abstract class AbstractCompiler
 	fun compile_main_function
 	do
 		var v = self.new_visitor
+		v.add_decl("#include <signal.h>")
+		var ost = modelbuilder.toolcontext.opt_stacktrace.value
+
+		if ost == null then
+			ost = "nitstack"
+			modelbuilder.toolcontext.opt_stacktrace.value = ost
+		end
+
+		if ost == "nitstack" or ost == "libunwind" then
+			v.add_decl("#define UNW_LOCAL_ONLY")
+			v.add_decl("#include <libunwind.h>")
+			if ost == "nitstack" then
+				v.add_decl("#include \"c_functions_hash.h\"")
+			end
+		end
 		v.add_decl("int glob_argc;")
 		v.add_decl("char **glob_argv;")
 		v.add_decl("val *glob_sys;")
@@ -337,7 +565,71 @@ abstract class AbstractCompiler
 				v.compiler.header.add_decl("extern long count_type_test_skipped_{tag};")
 			end
 		end
+
+		if self.modelbuilder.toolcontext.opt_invocation_metrics.value then
+			v.add_decl("long count_invoke_by_tables;")
+			v.add_decl("long count_invoke_by_direct;")
+			v.add_decl("long count_invoke_by_inline;")
+			v.compiler.header.add_decl("extern long count_invoke_by_tables;")
+			v.compiler.header.add_decl("extern long count_invoke_by_direct;")
+			v.compiler.header.add_decl("extern long count_invoke_by_inline;")
+		end
+
+		if self.modelbuilder.toolcontext.opt_isset_checks_metrics.value then
+			v.add_decl("long count_attr_reads = 0;")
+			v.add_decl("long count_isset_checks = 0;")
+			v.compiler.header.add_decl("extern long count_attr_reads;")
+			v.compiler.header.add_decl("extern long count_isset_checks;")
+		end
+
+		v.add_decl("void sig_handler(int signo)\{")
+		v.add_decl("printf(\"Caught signal : %s\\n\", strsignal(signo));")
+		v.add_decl("show_backtrace(signo);")
+		v.add_decl("\}")
+
+		v.add_decl("void show_backtrace (int signo) \{")
+		if ost == "nitstack" or ost == "libunwind" then
+			v.add_decl("char* opt = getenv(\"NIT_NO_STACK\");")
+			v.add_decl("unw_cursor_t cursor;")
+			v.add_decl("if(opt==NULL)\{")
+			v.add_decl("unw_context_t uc;")
+			v.add_decl("unw_word_t ip;")
+			v.add_decl("char* procname = malloc(sizeof(char) * 100);")
+			v.add_decl("unw_getcontext(&uc);")
+			v.add_decl("unw_init_local(&cursor, &uc);")
+			v.add_decl("printf(\"-------------------------------------------------\\n\");")
+			v.add_decl("printf(\"--   Stack Trace   ------------------------------\\n\");")
+			v.add_decl("printf(\"-------------------------------------------------\\n\");")
+			v.add_decl("while (unw_step(&cursor) > 0) \{")
+			v.add_decl("	unw_get_proc_name(&cursor, procname, 100, &ip);")
+			if ost == "nitstack" then
+			v.add_decl("	const char* recv = get_nit_name(procname, strlen(procname));")
+			v.add_decl("	if (recv != NULL)\{")
+			v.add_decl("		printf(\"` %s\\n\", recv);")
+			v.add_decl("	\}else\{")
+			v.add_decl("		printf(\"` %s\\n\", procname);")
+			v.add_decl("	\}")
+			else
+			v.add_decl("	printf(\"` %s \\n\",procname);")
+			end
+			v.add_decl("\}")
+			v.add_decl("printf(\"-------------------------------------------------\\n\");")
+			v.add_decl("free(procname);")
+			v.add_decl("\}")
+		end
+		v.add_decl("exit(signo);")
+		v.add_decl("\}")
+
 		v.add_decl("int main(int argc, char** argv) \{")
+
+		v.add("signal(SIGABRT, sig_handler);")
+		v.add("signal(SIGFPE, sig_handler);")
+		v.add("signal(SIGILL, sig_handler);")
+		v.add("signal(SIGINT, sig_handler);")
+		v.add("signal(SIGTERM, sig_handler);")
+		v.add("signal(SIGSEGV, sig_handler);")
+		v.add("signal(SIGPIPE, sig_handler);")
+
 		v.add("glob_argc = argc; glob_argv = argv;")
 		v.add("initialize_gc_option();")
 		var main_type = mainmodule.sys_type
@@ -380,19 +672,34 @@ abstract class AbstractCompiler
 				v.add("printf(\"\\t%ld (%.2f%%)\\n\", count_type_test_total_{tag}, 100.0*count_type_test_total_{tag}/count_type_test_total_total);")
 			end
 		end
+
+		if self.modelbuilder.toolcontext.opt_invocation_metrics.value then
+			v.add_decl("long count_invoke_total;")
+			v.add("count_invoke_total = count_invoke_by_tables + count_invoke_by_direct + count_invoke_by_inline;")
+			v.add("printf(\"# dynamic count_invocation: total %ld\\n\", count_invoke_total);")
+			v.add("printf(\"by table: %ld (%.2f%%)\\n\", count_invoke_by_tables, 100.0*count_invoke_by_tables/count_invoke_total);")
+			v.add("printf(\"direct:   %ld (%.2f%%)\\n\", count_invoke_by_direct, 100.0*count_invoke_by_direct/count_invoke_total);")
+			v.add("printf(\"inlined:  %ld (%.2f%%)\\n\", count_invoke_by_inline, 100.0*count_invoke_by_inline/count_invoke_total);")
+		end
+
+		if self.modelbuilder.toolcontext.opt_isset_checks_metrics.value then
+			v.add("printf(\"# dynamic attribute reads: %ld\\n\", count_attr_reads);")
+			v.add("printf(\"# dynamic isset checks: %ld\\n\", count_isset_checks);")
+		end
+
 		v.add("return 0;")
 		v.add("\}")
 	end
 
-	# List of additional .c files required to compile (native interface)
-	var extern_bodies = new Array[ExternCFile]
+	# List of additional files required to compile (FFI)
+	var extern_bodies = new Array[ExternFile]
+
+	# List of source files to copy over to the compile dir
+	var files_to_copy = new Array[String]
 
 	# This is used to avoid adding an extern file more than once
 	private var seen_extern = new ArraySet[String]
 
-	# Generate code that check if an instance is correctly initialized
-	fun generate_check_init_instance(mtype: MClassType) is abstract
-
 	# Generate code that initialize the attributes on a new instance
 	fun generate_init_attr(v: VISITOR, recv: RuntimeVariable, mtype: MClassType)
 	do
@@ -441,8 +748,8 @@ abstract class AbstractCompiler
 
 	# Display stats about compilation process
 	# Metrics used:
-	#	* type tests against resolved types (x isa Collection[Animal])
-	#	* type tests against unresolved types (x isa Collection[E])
+	#	* type tests against resolved types (`x isa Collection[Animal]`)
+	#	* type tests against unresolved types (`x isa Collection[E]`)
 	#	* type tests skipped
 	#	* type tests total
 	# 	*
@@ -477,6 +784,8 @@ abstract class AbstractCompiler
 		end
 	end
 
+	fun finalize_ffi_for_module(mmodule: MModule) do mmodule.finalize_ffi(self)
+
 	# Division facility
 	# Avoid division by zero by returning the string "n/a"
 	fun div(a,b:Int):String
@@ -525,7 +834,7 @@ abstract class AbstractCompilerVisitor
 	# The current visited AST node
 	var current_node: nullable ANode writable = null
 
-	# The current Frame
+	# The current `Frame`
 	var frame: nullable Frame writable
 
 	# Alias for self.compiler.mainmodule.object_type
@@ -542,10 +851,10 @@ abstract class AbstractCompilerVisitor
 		self.writer = new CodeWriter(compiler.files.last)
 	end
 
-	# Force to get the primitive class named `name' or abort
+	# Force to get the primitive class named `name` or abort
 	fun get_class(name: String): MClass do return self.compiler.mainmodule.get_primitive_class(name)
 
-	# Force to get the primitive property named `name' in the instance `recv' or abort
+	# Force to get the primitive property named `name` in the instance `recv` or abort
 	fun get_property(name: String, recv: MType): MMethod
 	do
 		assert recv isa MClassType
@@ -561,7 +870,7 @@ abstract class AbstractCompilerVisitor
 
 	fun native_array_def(pname: String, ret_type: nullable MType, arguments: Array[RuntimeVariable]) is abstract
 
-	# Transform varargs, in raw arguments, into a single argument of type Array
+	# Transform varargs, in raw arguments, into a single argument of type `Array`
 	# Note: this method modify the given `args`
 	# If there is no vararg, then `args` is not modified.
 	fun varargize(mpropdef: MPropDef, msignature: MSignature, args: Array[RuntimeVariable])
@@ -613,8 +922,8 @@ abstract class AbstractCompilerVisitor
 
 	# Unsafely cast a value to a new type
 	# ie the result share the same C variable but my have a different mcasttype
-	# NOTE: if the adaptation is useless then `value' is returned as it.
-	# ENSURE: return.name == value.name
+	# NOTE: if the adaptation is useless then `value` is returned as it.
+	# ENSURE: `result.name == value.name`
 	fun autoadapt(value: RuntimeVariable, mtype: MType): RuntimeVariable
 	do
 		mtype = self.anchor(mtype)
@@ -638,7 +947,7 @@ abstract class AbstractCompilerVisitor
 	fun adapt_signature(m: MMethodDef, args: Array[RuntimeVariable]) is abstract
 
 	# Box or unbox a value to another type iff a C type conversion is needed
- 	# ENSURE: result.mtype.ctype == mtype.ctype
+	# ENSURE: `result.mtype.ctype == mtype.ctype`
 	fun autobox(value: RuntimeVariable, mtype: MType): RuntimeVariable is abstract
 
 	#  Generate a polymorphic subtype test
@@ -655,10 +964,10 @@ abstract class AbstractCompilerVisitor
 	#  Generate a static call on a method definition
 	fun call(m: MMethodDef, recvtype: MClassType, args: Array[RuntimeVariable]): nullable RuntimeVariable is abstract
 
-	#  Generate a polymorphic send for the method `m' and the arguments `args'
+	#  Generate a polymorphic send for the method `m` and the arguments `args`
 	fun send(m: MMethod, args: Array[RuntimeVariable]): nullable RuntimeVariable is abstract
 
-	# Generate a monomorphic send for the method `m', the type `t' and the arguments `args'
+	# Generate a monomorphic send for the method `m`, the type `t` and the arguments `args`
 	fun monomorphic_send(m: MMethod, t: MType, args: Array[RuntimeVariable]): nullable RuntimeVariable
 	do
 		assert t isa MClassType
@@ -666,6 +975,14 @@ abstract class AbstractCompilerVisitor
 		return self.call(propdef, t, args)
 	end
 
+	# Generate a monomorphic super send from the method `m`, the type `t` and the arguments `args`
+	fun monomorphic_super_send(m: MMethodDef, t: MType, args: Array[RuntimeVariable]): nullable RuntimeVariable
+	do
+		assert t isa MClassType
+		m = m.lookup_next_definition(self.compiler.mainmodule, t)
+		return self.call(m, t, args)
+	end
+
 	# Attributes handling
 
 	# Generate a polymorphic attribute is_set test
@@ -686,21 +1003,18 @@ abstract class AbstractCompilerVisitor
 
 		var maybenull = recv.mcasttype isa MNullableType or recv.mcasttype isa MNullType
 		if maybenull then
-			self.add("if ({recv} == NULL) \{")
-			self.add_abort("Reciever is null")
+			self.add("if (unlikely({recv} == NULL)) \{")
+			self.add_abort("Receiver is null")
 			self.add("\}")
 		end
 	end
 
-	# Generate a check-init-instance
-	fun check_init_instance(recv: RuntimeVariable, mtype: MClassType) is abstract
-
 	# Names handling
 
 	private var names: HashSet[String] = new HashSet[String]
 	private var last: Int = 0
 
-	# Return a new name based on `s' and unique in the visitor
+	# Return a new name based on `s` and unique in the visitor
 	fun get_name(s: String): String
 	do
 		if not self.names.has(s) then
@@ -734,7 +1048,7 @@ abstract class AbstractCompilerVisitor
 	private var escapemark_names = new HashMap[EscapeMark, String]
 
 	# Return a "const char*" variable associated to the classname of the dynamic type of an object
- 	# NOTE: we do not return a RuntimeVariable "NativeString" as the class may not exist in the module/program
+ 	# NOTE: we do not return a `RuntimeVariable` "NativeString" as the class may not exist in the module/program
 	fun class_name_string(value: RuntimeVariable): String is abstract
 
 	# Variables handling
@@ -807,13 +1121,11 @@ abstract class AbstractCompilerVisitor
 		self.add("if ({name}) \{")
 		self.add("{res} = {name};")
 		self.add("\} else \{")
-		var nat = self.new_var(self.get_class("NativeString").mclass_type)
+		var native_mtype = self.get_class("NativeString").mclass_type
+		var nat = self.new_var(native_mtype)
 		self.add("{nat} = \"{string.escape_to_c}\";")
-		var res2 = self.init_instance(mtype)
-		self.add("{res} = {res2};")
 		var length = self.int_instance(string.length)
-		self.send(self.get_property("with_native", mtype), [res, nat, length])
-		self.check_init_instance(res, mtype)
+		self.add("{res} = {self.send(self.get_property("to_s_with_length", native_mtype), [nat, length]).as(not null)};")
 		self.add("{name} = {res};")
 		self.add("\}")
 		return res
@@ -837,7 +1149,11 @@ abstract class AbstractCompilerVisitor
 	# Request the presence of a global declaration
 	fun require_declaration(key: String)
 	do
-		self.writer.file.required_declarations.add(key)
+		var reqs = self.writer.file.required_declarations
+		if reqs.has(key) then return
+		reqs.add(key)
+		var node = current_node
+		if node != null then compiler.requirers_of_declarations[key] = node
 	end
 
 	# Add a declaration in the local-header
@@ -849,17 +1165,19 @@ abstract class AbstractCompilerVisitor
 	end
 
 	# look for a needed .h and .c file for a given .nit source-file
-	# FIXME: bad API, parameter should be a MModule, not its source-file
+	# FIXME: bad API, parameter should be a `MModule`, not its source-file
 	fun add_extern(file: String)
 	do
 		file = file.strip_extension(".nit")
 		var tryfile = file + ".nit.h"
 		if tryfile.file_exists then
-			self.declare_once("#include \"{"..".join_path(tryfile)}\"")
+			self.declare_once("#include \"{tryfile.basename("")}\"")
+			self.compiler.files_to_copy.add(tryfile)
 		end
 		tryfile = file + "_nit.h"
 		if tryfile.file_exists then
-			self.declare_once("#include \"{"..".join_path(tryfile)}\"")
+			self.declare_once("#include \"{tryfile.basename("")}\"")
+			self.compiler.files_to_copy.add(tryfile)
 		end
 
 		if self.compiler.seen_extern.has(file) then return
@@ -869,11 +1187,12 @@ abstract class AbstractCompilerVisitor
 			tryfile = file + "_nit.c"
 			if not tryfile.file_exists then return
 		end
-		var f = new ExternCFile(tryfile, "")
+		var f = new ExternCFile(tryfile.basename(""), "")
 		self.compiler.extern_bodies.add(f)
+		self.compiler.files_to_copy.add(tryfile)
 	end
 
-	# Return a new local runtime_variable initialized with the C expression `cexpr'.
+	# Return a new local runtime_variable initialized with the C expression `cexpr`.
 	fun new_expr(cexpr: String, mtype: MType): RuntimeVariable
 	do
 		var res = new_var(mtype)
@@ -885,15 +1204,32 @@ abstract class AbstractCompilerVisitor
 	# used by aborts, asserts, casts, etc.
 	fun add_abort(message: String)
 	do
+		self.add("fprintf(stderr, \"Runtime error: %s\", \"{message.escape_to_c}\");")
+		add_raw_abort
+	end
+
+	fun add_raw_abort
+	do
 		if self.current_node != null and self.current_node.location.file != null then
-			self.add("fprintf(stderr, \"Runtime error: %s (%s:%d)\\n\", \"{message.escape_to_c}\", \"{self.current_node.location.file.filename.escape_to_c}\", {current_node.location.line_start});")
+			self.add("fprintf(stderr, \" (%s:%d)\\n\", \"{self.current_node.location.file.filename.escape_to_c}\", {current_node.location.line_start});")
 		else
-			self.add("fprintf(stderr, \"Runtime error: %s\\n\", \"{message.escape_to_c}\");")
+			self.add("fprintf(stderr, \"\\n\");")
 		end
-		self.add("exit(1);")
+		self.add("show_backtrace(1);")
 	end
 
-	# Generate a return with the value `s'
+	# Add a dynamic cast
+	fun add_cast(value: RuntimeVariable, mtype: MType, tag: String)
+	do
+		var res = self.type_test(value, mtype, tag)
+		self.add("if (unlikely(!{res})) \{")
+		var cn = self.class_name_string(value)
+		self.add("fprintf(stderr, \"Runtime error: Cast failed. Expected `%s`, got `%s`\", \"{mtype.to_s.escape_to_c}\", {cn});")
+		self.add_raw_abort
+		self.add("\}")
+	end
+
+	# Generate a return with the value `s`
 	fun ret(s: RuntimeVariable)
 	do
 		self.assign(self.frame.returnvar.as(not null), s)
@@ -924,17 +1260,14 @@ abstract class AbstractCompilerVisitor
 		res = autoadapt(res, nexpr.mtype.as(not null))
 		var implicit_cast_to = nexpr.implicit_cast_to
 		if implicit_cast_to != null and not self.compiler.modelbuilder.toolcontext.opt_no_check_autocast.value then
-			var castres = self.type_test(res, implicit_cast_to, "auto")
-			self.add("if (!{castres}) \{")
-			self.add_abort("Cast failed")
-			self.add("\}")
+			add_cast(res, implicit_cast_to, "auto")
 			res = autoadapt(res, implicit_cast_to)
 		end
 		self.current_node = old
 		return res
 	end
 
-	# Alias for `self.expr(nexpr, self.bool_type)'
+	# Alias for `self.expr(nexpr, self.bool_type)`
 	fun expr_bool(nexpr: AExpr): RuntimeVariable do return expr(nexpr, bool_type)
 
 	# Safely show a debug message on the current node and repeat the message in the C code as a comment
@@ -980,7 +1313,7 @@ abstract class AbstractRuntimeFunction
 	# May inline the body or generate a C function call
 	fun call(v: VISITOR, arguments: Array[RuntimeVariable]): nullable RuntimeVariable is abstract
 
-	# Generate the code for the RuntimeFunction
+	# Generate the code for the `AbstractRuntimeFunction`
 	# Warning: compile more than once compilation makes CC unhappy
 	fun compile_to_c(compiler: COMPILER) is abstract
 end
@@ -988,7 +1321,7 @@ end
 # A runtime variable hold a runtime value in C.
 # Runtime variables are associated to Nit local variables and intermediate results in Nit expressions.
 #
-# The tricky point is that a single C variable can be associated to more than one RuntimeVariable because the static knowledge of the type of an expression can vary in the C code.
+# The tricky point is that a single C variable can be associated to more than one `RuntimeVariable` because the static knowledge of the type of an expression can vary in the C code.
 class RuntimeVariable
 	# The name of the variable in the C code
 	var name: String
@@ -1032,7 +1365,7 @@ class RuntimeVariable
 	end
 end
 
-# A frame correspond to a visited property in a GlobalCompilerVisitor
+# A frame correspond to a visited property in a `GlobalCompilerVisitor`
 class Frame
 
 	type VISITOR: AbstractCompilerVisitor
@@ -1057,71 +1390,6 @@ class Frame
 	var returnlabel: nullable String writable = null
 end
 
-# An extern C file to compile
-class ExternCFile
-	# The filename of the file
-	var filename: String
-	# Additionnal specific CC compiler -c flags
-	var cflags: String
-end
-
-redef class String
-	# Mangle a string to be a unique valid C identifier
-	fun to_cmangle: String
-	do
-		var res = new Buffer
-		var underscore = false
-		for c in self do
-			if (c >= 'a' and c <= 'z') or (c >='A' and c <= 'Z') then
-				res.add(c)
-				underscore = false
-				continue
-			end
-			if underscore then
-				res.append('_'.ascii.to_s)
-				res.add('d')
-			end
-			if c >= '0' and c <= '9' then
-				res.add(c)
-				underscore = false
-			else if c == '_' then
-				res.add(c)
-				underscore = true
-			else
-				res.add('_')
-				res.append(c.ascii.to_s)
-				res.add('d')
-				underscore = false
-			end
-		end
-		return res.to_s
-	end
-
-	# Escape " \ ' and non printable characters for literal C strings or characters
-	fun escape_to_c: String
-	do
-		var b = new Buffer
-		for c in self do
-			if c == '\n' then
-				b.append("\\n")
-			else if c == '\0' then
-				b.append("\\0")
-			else if c == '"' then
-				b.append("\\\"")
-			else if c == '\'' then
-				b.append("\\\'")
-			else if c == '\\' then
-				b.append("\\\\")
-			else if c.ascii < 32 then
-				b.append("\\{c.ascii.to_base(8, false)}")
-			else
-				b.add(c)
-			end
-		end
-		return b.to_s
-	end
-end
-
 redef class MType
 	# Return the C type associated to a given Nit static type
 	fun ctype: String do return "val*"
@@ -1277,6 +1545,7 @@ redef class MMethodDef
 	# Can the body be inlined?
 	fun can_inline(v: VISITOR): Bool
 	do
+		if is_abstract then return true
 		var modelbuilder = v.compiler.modelbuilder
 		if modelbuilder.mpropdef2npropdef.has_key(self) then
 			var npropdef = modelbuilder.mpropdef2npropdef[self]
@@ -1332,10 +1601,7 @@ redef class MMethodDef
 			# generate the cast
 			# note that v decides if and how to implements the cast
 			v.add("/* Covariant cast for argument {i} ({self.msignature.mparameters[i].name}) {arguments[i+1].inspect} isa {mtype} */")
-			var cond = v.type_test(arguments[i+1], mtype, "covariance")
-			v.add("if (!{cond}) \{")
-			v.add_abort("Cast failed")
-			v.add("\}")
+			v.add_cast(arguments[i+1], mtype, "covariance")
 		end
 	end
 end
@@ -1352,26 +1618,45 @@ redef class APropdef
 	fun can_inline: Bool do return true
 end
 
-redef class AConcreteMethPropdef
+redef class AMethPropdef
 	redef fun compile_to_c(v, mpropdef, arguments)
 	do
-		for i in [0..mpropdef.msignature.arity[ do
-			var variable = self.n_signature.n_params[i].variable.as(not null)
-			v.assign(v.variable(variable), arguments[i+1])
+		if mpropdef.is_abstract then
+			var cn = v.class_name_string(arguments.first)
+			v.add("fprintf(stderr, \"Runtime error: Abstract method `%s` called on `%s`\", \"{mpropdef.mproperty.name.escape_to_c}\", {cn});")
+			v.add_raw_abort
+			return
 		end
+
 		# Call the implicit super-init
 		var auto_super_inits = self.auto_super_inits
 		if auto_super_inits != null then
-			var selfarg = [arguments.first]
+			var args = [arguments.first]
 			for auto_super_init in auto_super_inits do
-				if auto_super_init.intro.msignature.arity == 0 then
-					v.send(auto_super_init, selfarg)
-				else
-					v.send(auto_super_init, arguments)
+				args.clear
+				for i in [0..auto_super_init.msignature.arity+1[ do
+					args.add(arguments[i])
 				end
+				v.compile_callsite(auto_super_init, args)
+			end
+		end
+
+		var n_block = n_block
+		if n_block != null then
+			for i in [0..mpropdef.msignature.arity[ do
+				var variable = self.n_signature.n_params[i].variable.as(not null)
+				v.assign(v.variable(variable), arguments[i+1])
+			end
+			v.stmt(n_block)
+		else if mpropdef.is_intern then
+			compile_intern_to_c(v, mpropdef, arguments)
+		else if mpropdef.is_extern then
+			if mpropdef.mproperty.is_init then
+				compile_externinit_to_c(v, mpropdef, arguments)
+			else
+				compile_externmeth_to_c(v, mpropdef, arguments)
 			end
 		end
-		v.stmt(self.n_block)
 	end
 
 	redef fun can_inline
@@ -1383,10 +1668,8 @@ redef class AConcreteMethPropdef
 		if nblock isa ABlockExpr and nblock.n_expr.length == 0 then return true
 		return false
 	end
-end
 
-redef class AInternMethPropdef
-	redef fun compile_to_c(v, mpropdef, arguments)
+	fun compile_intern_to_c(v: AbstractCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable])
 	do
 		var pname = mpropdef.mproperty.name
 		var cname = mpropdef.mclassdef.mclass.name
@@ -1413,12 +1696,6 @@ redef class AInternMethPropdef
 			else if pname == "unary -" then
 				v.ret(v.new_expr("-{arguments[0]}", ret.as(not null)))
 				return
-			else if pname == "succ" then
-				v.ret(v.new_expr("{arguments[0]}+1", ret.as(not null)))
-				return
-			else if pname == "prec" then
-				v.ret(v.new_expr("{arguments[0]}-1", ret.as(not null)))
-				return
 			else if pname == "*" then
 				v.ret(v.new_expr("{arguments[0]} * {arguments[1]}", ret.as(not null)))
 				return
@@ -1465,12 +1742,12 @@ redef class AInternMethPropdef
 				v.add("printf(\"%c\", {arguments.first});")
 				return
 			else if pname == "object_id" then
-				v.ret(arguments.first)
+				v.ret(v.new_expr("(long){arguments.first}", ret.as(not null)))
 				return
-			else if pname == "+" then
+			else if pname == "successor" then
 				v.ret(v.new_expr("{arguments[0]} + {arguments[1]}", ret.as(not null)))
 				return
-			else if pname == "-" then
+			else if pname == "predecessor" then
 				v.ret(v.new_expr("{arguments[0]} - {arguments[1]}", ret.as(not null)))
 				return
 			else if pname == "==" then
@@ -1480,12 +1757,6 @@ redef class AInternMethPropdef
 				var res = v.equal_test(arguments[0], arguments[1])
 				v.ret(v.new_expr("!{res}", ret.as(not null)))
 				return
-			else if pname == "succ" then
-				v.ret(v.new_expr("{arguments[0]}+1", ret.as(not null)))
-				return
-			else if pname == "prec" then
-				v.ret(v.new_expr("{arguments[0]}-1", ret.as(not null)))
-				return
 			else if pname == "<" then
 				v.ret(v.new_expr("{arguments[0]} < {arguments[1]}", ret.as(not null)))
 				return
@@ -1510,7 +1781,7 @@ redef class AInternMethPropdef
 				v.add("printf({arguments.first}?\"true\\n\":\"false\\n\");")
 				return
 			else if pname == "object_id" then
-				v.ret(arguments.first)
+				v.ret(v.new_expr("(long){arguments.first}", ret.as(not null)))
 				return
 			else if pname == "==" then
 				v.ret(v.equal_test(arguments[0], arguments[1]))
@@ -1571,24 +1842,6 @@ redef class AInternMethPropdef
 				v.ret(v.new_expr("(long){arguments[0]}", ret.as(not null)))
 				return
 			end
-		else if cname == "Char" then
-			if pname == "output" then
-				v.add("printf(\"%c\", {arguments.first});")
-				return
-			else if pname == "object_id" then
-				v.ret(arguments.first)
-				return
-			else if pname == "==" then
-				v.ret(v.equal_test(arguments[0], arguments[1]))
-				return
-			else if pname == "!=" then
-				var res = v.equal_test(arguments[0], arguments[1])
-				v.ret(v.new_expr("!{res}", ret.as(not null)))
-				return
-			else if pname == "ascii" then
-				v.ret(v.new_expr("{arguments[0]}", ret.as(not null)))
-				return
-			end
 		else if cname == "NativeString" then
 			if pname == "[]" then
 				v.ret(v.new_expr("{arguments[0]}[{arguments[1]}]", ret.as(not null)))
@@ -1625,6 +1878,9 @@ redef class AInternMethPropdef
 		else if pname == "is_same_type" then
 			v.ret(v.is_same_type_test(arguments[0], arguments[1]))
 			return
+		else if pname == "is_same_instance" then
+			v.ret(v.equal_test(arguments[0], arguments[1]))
+			return
 		else if pname == "output_class_name" then
 			var nat = v.class_name_string(arguments.first)
 			v.add("printf(\"%s\\n\", {nat});")
@@ -1646,16 +1902,14 @@ redef class AInternMethPropdef
 		v.add("printf(\"NOT YET IMPLEMENTED {class_name}:{mpropdef} at {location.to_s}\\n\");")
 		debug("Not implemented {mpropdef}")
 	end
-end
 
-redef class AExternMethPropdef
-	redef fun compile_to_c(v, mpropdef, arguments)
+	fun compile_externmeth_to_c(v: AbstractCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable])
 	do
 		var externname
 		var nextern = self.n_extern
 		if nextern == null then
 			v.add("fprintf(stderr, \"NOT YET IMPLEMENTED nitni for {mpropdef} at {location.to_s}\\n\");")
-			v.add("exit(1);")
+			v.add("show_backtrace(1);")
 			return
 		end
 		externname = nextern.text.substring(1, nextern.text.length-2)
@@ -1678,16 +1932,14 @@ redef class AExternMethPropdef
 			v.ret(res)
 		end
 	end
-end
 
-redef class AExternInitPropdef
-	redef fun compile_to_c(v, mpropdef, arguments)
+	fun compile_externinit_to_c(v: AbstractCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable])
 	do
 		var externname
 		var nextern = self.n_extern
 		if nextern == null then
 			v.add("printf(\"NOT YET IMPLEMENTED nitni for {mpropdef} at {location.to_s}\\n\");")
-			v.add("exit(1);")
+			v.add("show_backtrace(1);")
 			return
 		end
 		externname = nextern.text.substring(1, nextern.text.length-2)
@@ -1777,14 +2029,9 @@ redef class AClassdef
 	end
 end
 
-redef class ADeferredMethPropdef
-	redef fun compile_to_c(v, mpropdef, arguments) do v.add_abort("Deferred method called")
-	redef fun can_inline do return true
-end
-
 redef class AExpr
 	# Try to compile self as an expression
-	# Do not call this method directly, use `v.expr' instead
+	# Do not call this method directly, use `v.expr` instead
 	private fun expr(v: AbstractCompilerVisitor): nullable RuntimeVariable
 	do
 		v.add("printf(\"NOT YET IMPLEMENTED {class_name}:{location.to_s}\\n\");")
@@ -1799,7 +2046,7 @@ redef class AExpr
 	end
 
 	# Try to compile self as a statement
-	# Do not call this method directly, use `v.stmt' instead
+	# Do not call this method directly, use `v.stmt` instead
 	private fun stmt(v: AbstractCompilerVisitor)
 	do
 		var res = expr(v)
@@ -2006,29 +2253,29 @@ redef class AForExpr
 		var cl = v.expr(self.n_expr, null)
 		var it_meth = self.method_iterator
 		assert it_meth != null
-		var it = v.send(it_meth, [cl])
+		var it = v.compile_callsite(it_meth, [cl])
 		assert it != null
 		v.add("for(;;) \{")
 		var isok_meth = self.method_is_ok
 		assert isok_meth != null
-		var ok = v.send(isok_meth, [it])
+		var ok = v.compile_callsite(isok_meth, [it])
 		assert ok != null
 		v.add("if(!{ok}) break;")
 		if self.variables.length == 1 then
 			var item_meth = self.method_item
 			assert item_meth != null
-			var i = v.send(item_meth, [it])
+			var i = v.compile_callsite(item_meth, [it])
 			assert i != null
 			v.assign(v.variable(variables.first), i)
 		else if self.variables.length == 2 then
 			var key_meth = self.method_key
 			assert key_meth != null
-			var i = v.send(key_meth, [it])
+			var i = v.compile_callsite(key_meth, [it])
 			assert i != null
 			v.assign(v.variable(variables[0]), i)
 			var item_meth = self.method_item
 			assert item_meth != null
-			i = v.send(item_meth, [it])
+			i = v.compile_callsite(item_meth, [it])
 			assert i != null
 			v.assign(v.variable(variables[1]), i)
 		else
@@ -2038,7 +2285,7 @@ redef class AForExpr
 		v.add("CONTINUE_{v.escapemark_name(escapemark)}: (void)0;")
 		var next_meth = self.method_next
 		assert next_meth != null
-		v.send(next_meth, [it])
+		v.compile_callsite(next_meth, [it])
 		v.add("\}")
 		v.add("BREAK_{v.escapemark_name(escapemark)}: (void)0;")
 	end
@@ -2050,7 +2297,7 @@ redef class AAssertExpr
 		if v.compiler.modelbuilder.toolcontext.opt_no_check_assert.value then return
 
 		var cond = v.expr_bool(self.n_expr)
-		v.add("if (!{cond}) \{")
+		v.add("if (unlikely(!{cond})) \{")
 		v.stmt(self.n_else)
 		var nid = self.n_id
 		if nid != null then
@@ -2077,6 +2324,21 @@ redef class AOrExpr
 	end
 end
 
+redef class AImpliesExpr
+	redef fun expr(v)
+	do
+		var res = v.new_var(self.mtype.as(not null))
+		var i1 = v.expr_bool(self.n_expr)
+		v.add("if (!{i1}) \{")
+		v.add("{res} = 1;")
+		v.add("\} else \{")
+		var i2 = v.expr_bool(self.n_expr2)
+		v.add("{res} = {i2};")
+		v.add("\}")
+		return res
+	end
+end
+
 redef class AAndExpr
 	redef fun expr(v)
 	do
@@ -2115,25 +2377,16 @@ redef class AOrElseExpr
 	end
 end
 
-redef class AEeExpr
-	redef fun expr(v)
-	do
-		var value1 = v.expr(self.n_expr, null)
-		var value2 = v.expr(self.n_expr2, null)
-		return v.equal_test(value1, value2)
-	end
-end
-
 redef class AIntExpr
-	redef fun expr(v) do return v.new_expr("{self.n_number.text}", self.mtype.as(not null))
+	redef fun expr(v) do return v.new_expr("{self.value.to_s}", self.mtype.as(not null))
 end
 
 redef class AFloatExpr
-	redef fun expr(v) do return v.new_expr("{self.n_float.text}", self.mtype.as(not null))
+	redef fun expr(v) do return v.new_expr("{self.n_float.text}", self.mtype.as(not null)) # FIXME use value, not n_float
 end
 
 redef class ACharExpr
-	redef fun expr(v) do return v.new_expr("{self.n_char.text}", self.mtype.as(not null))
+	redef fun expr(v) do return v.new_expr("'{self.value.to_s.escape_to_c}'", self.mtype.as(not null))
 end
 
 redef class AArrayExpr
@@ -2175,8 +2428,7 @@ redef class ACrangeExpr
 		var i2 = v.expr(self.n_expr2, null)
 		var mtype = self.mtype.as(MClassType)
 		var res = v.init_instance(mtype)
-		var it = v.send(v.get_property("init", res.mtype), [res, i1, i2])
-		v.check_init_instance(res, mtype)
+		var it = v.compile_callsite(init_callsite.as(not null), [res, i1, i2])
 		return res
 	end
 end
@@ -2188,8 +2440,7 @@ redef class AOrangeExpr
 		var i2 = v.expr(self.n_expr2, null)
 		var mtype = self.mtype.as(MClassType)
 		var res = v.init_instance(mtype)
-		var it = v.send(v.get_property("without_last", res.mtype), [res, i1, i2])
-		v.check_init_instance(res, mtype)
+		var it = v.compile_callsite(init_callsite.as(not null), [res, i1, i2])
 		return res
 	end
 end
@@ -2220,10 +2471,7 @@ redef class AAsCastExpr
 		var i = v.expr(self.n_expr, null)
 		if v.compiler.modelbuilder.toolcontext.opt_no_check_assert.value then return i
 
-		var cond = v.type_test(i, self.mtype.as(not null), "as")
-		v.add("if (!{cond}) \{")
-		v.add_abort("Cast failed")
-		v.add("\}")
+		v.add_cast(i, self.mtype.as(not null), "as")
 		return i
 	end
 end
@@ -2234,7 +2482,7 @@ redef class AAsNotnullExpr
 		var i = v.expr(self.n_expr, null)
 		if v.compiler.modelbuilder.toolcontext.opt_no_check_assert.value then return i
 
-		v.add("if ({i} == NULL) \{")
+		v.add("if (unlikely({i} == NULL)) \{")
 		v.add_abort("Cast failed")
 		v.add("\}")
 		return i
@@ -2307,22 +2555,26 @@ redef class ASuperExpr
 		for a in self.n_args.n_exprs do
 			args.add(v.expr(a, null))
 		end
-		if args.length == 1 then
-			args = v.frame.arguments
-		end
 
-		var mproperty = self.mproperty
-		if mproperty != null then
-			if mproperty.intro.msignature.arity == 0 then
-				args = [recv]
+		var callsite = self.callsite
+		if callsite != null then
+			# Add additionnals arguments for the super init call
+			if args.length == 1 then
+				for i in [0..callsite.mproperty.intro.msignature.arity[ do
+					args.add(v.frame.arguments[i+1])
+				end
 			end
 			# Super init call
-			var res = v.send(mproperty, args)
+			var res = v.compile_callsite(callsite, args)
 			return res
 		end
 
+		if args.length == 1 then
+			args = v.frame.arguments
+		end
+
 		# stantard call-next-method
-		return v.supercall(v.frame.mpropdef.as(MMethodDef), recv.mtype.as(MClassType), args)
+		return v.supercall(mpropdef.as(not null), recv.mtype.as(MClassType), args)
 	end
 end
 
@@ -2349,7 +2601,6 @@ redef class ANewExpr
 			#self.debug("got {res2} from {mproperty}. drop {recv}")
 			return res2
 		end
-		v.check_init_instance(recv, mtype)
 		return recv
 	end
 end
@@ -2405,7 +2656,7 @@ end
 # Utils
 
 redef class Array[E]
-	# Return a new Array with the elements only contened in 'self' and not in 'o'
+	# Return a new `Array` with the elements only contened in self and not in `o`
 	fun -(o: Array[E]): Array[E] do
 		var res = new Array[E]
 		for e in self do if not o.has(e) then res.add(e)
@@ -2414,7 +2665,7 @@ redef class Array[E]
 end
 
 redef class MModule
-	# All 'mproperties' associated to all 'mclassdefs' of `mclass`
+	# All `MProperty` associated to all `MClassDef` of `mclass`
 	fun properties(mclass: MClass): Set[MProperty] do
 		if not self.properties_cache.has_key(mclass) then
 			var properties = new HashSet[MProperty]
@@ -2435,4 +2686,11 @@ redef class MModule
 		return properties_cache[mclass]
 	end
 	private var properties_cache: Map[MClass, Set[MProperty]] = new HashMap[MClass, Set[MProperty]]
+
+	# Write FFI and nitni results to file
+	fun finalize_ffi(c: AbstractCompiler) do end
+
+	# Give requided addinional system libraries (as given to LD_LIBS)
+	# Note: can return null instead of an empty set
+	fun collect_linker_libs: nullable Set[String] do return null
 end