X-Git-Url: http://nitlanguage.org diff --git a/src/abstract_compiler.nit b/src/abstract_compiler.nit index 8e520fa..dae3d88 100644 --- a/src/abstract_compiler.nit +++ b/src/abstract_compiler.nit @@ -21,6 +21,8 @@ import literal import typing import auto_super_init import frontend +import platform +import c_tools # Add compiling options redef class ToolContext @@ -40,8 +42,8 @@ redef class ToolContext 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 @@ -50,39 +52,95 @@ 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") + # --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_compile_dir, 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_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.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 @@ -94,12 +152,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 @@ -107,17 +167,53 @@ redef class ModelBuilder var time0 = get_time self.toolcontext.info("*** WRITING C ***", 1) - var compile_dir = toolcontext.opt_compile_dir.value - if compile_dir == null then compile_dir = ".nit_compile" - compile_dir.mkdir - var orig_dir=".." # FIXME only works if `compile_dir` is a subdirectory of cwd - 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 outpath = orig_dir.join_path(outname).simplify_path var hfilename = compiler.header.file.name + ".h" var hfilepath = "{compile_dir}/{hfilename}" @@ -132,8 +228,6 @@ 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 @@ -144,7 +238,12 @@ redef class ModelBuilder 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] @@ -181,58 +280,89 @@ 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 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 = orig_dir.join_path(p).simplify_path cc_includes += " -I \"" + p + "\"" end - makefile.write("CC = ccache cc\nCFLAGS = -g -O2\nCINCL = {cc_includes}\nLDFLAGS ?= \nLDLIBS ?= -lm -lgc\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 = "{basename}.extern.o" - var ff = orig_dir.join_path(f.filename).simplify_path - makefile.write("{o}: {ff}\n\t$(CC) $(CFLAGS) -D NONITCNI {f.cflags} -c -o {o} {ff}\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("{outpath}: {ofiles.join(" ")}\n\t$(CC) $(LDFLAGS) -o {outpath} {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: {makepath}", 2) + end - 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 + 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 -C {compile_dir} -f {makename} -j 4 {makeflags}", 2) @@ -246,9 +376,6 @@ redef class ModelBuilder 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 @@ -256,6 +383,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 @@ -306,26 +436,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 \n") + stream.write("#include \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 ") self.header.add_decl("#include ") self.header.add_decl("#include ") - self.header.add_decl("#include ") + 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 @@ -334,6 +535,21 @@ abstract class AbstractCompiler fun compile_main_function do var v = self.new_visitor + v.add_decl("#include ") + 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 ") + 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;") @@ -348,7 +564,64 @@ 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 + + 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 @@ -391,19 +664,28 @@ 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 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 @@ -488,6 +770,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 @@ -677,6 +961,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 @@ -697,15 +989,12 @@ abstract class AbstractCompilerVisitor var maybenull = recv.mcasttype isa MNullableType or recv.mcasttype isa MNullType if maybenull then - self.add("if ({recv} == 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] @@ -846,7 +1135,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 @@ -864,11 +1157,13 @@ abstract class AbstractCompilerVisitor 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 @@ -878,8 +1173,9 @@ 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`. @@ -894,12 +1190,29 @@ 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 + + # 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` @@ -933,10 +1246,7 @@ 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 @@ -1066,14 +1376,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 MType # Return the C type associated to a given Nit static type fun ctype: String do return "val*" @@ -1284,10 +1586,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 @@ -1314,13 +1613,13 @@ redef class AConcreteMethPropdef # 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 v.stmt(self.n_block) @@ -1365,12 +1664,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 @@ -1419,10 +1712,10 @@ redef class AInternMethPropdef else if pname == "object_id" then 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 @@ -1432,12 +1725,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 @@ -1559,6 +1846,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});") @@ -1589,7 +1879,7 @@ redef class AExternMethPropdef 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) @@ -1621,7 +1911,7 @@ redef class AExternInitPropdef 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) @@ -1712,7 +2002,11 @@ redef class AClassdef end redef class ADeferredMethPropdef - redef fun compile_to_c(v, mpropdef, arguments) do v.add_abort("Deferred method called") + redef fun compile_to_c(v, mpropdef, arguments) do + 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 + end redef fun can_inline do return true end @@ -1940,29 +2234,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 @@ -1972,7 +2266,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 @@ -1984,7 +2278,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 @@ -2064,15 +2358,6 @@ 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.value.to_s}", self.mtype.as(not null)) end @@ -2124,8 +2409,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 @@ -2137,8 +2421,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 @@ -2169,10 +2452,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 @@ -2183,7 +2463,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 @@ -2256,22 +2536,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 @@ -2298,7 +2582,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 @@ -2384,4 +2667,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