X-Git-Url: http://nitlanguage.org diff --git a/src/abstract_compiler.nit b/src/abstract_compiler.nit index 53ccced..0f854ba 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 common_ffi +import platform # Add compiling options redef class ToolContext @@ -32,6 +34,8 @@ 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 @@ -48,17 +52,70 @@ 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") + # --no-stacktrace + var opt_no_stacktrace: OptionBool = new OptionBool("Disables libunwind and generation of C stack traces (can be problematic when compiling to targets such as Android or NaCl)", "--no-stacktrace") + # --stack-trace-C-to-Nit-name-binding + var opt_stacktrace: OptionBool = new OptionBool("Enables the use of gperf to bind C to Nit function names when encountering a Stack trace at runtime", "--nit-stacktrace") 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_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_stacktrace) + self.option_context.add_option(self.opt_no_stacktrace) end end redef class ModelBuilder + redef init(model, toolcontext) + do + if toolcontext.opt_no_stacktrace.value and toolcontext.opt_stacktrace.value then + print "Cannot use --nit-stacktrace when --no-stacktrace is activated" + exit(1) + end + + super + end + + # 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 @@ -67,10 +124,8 @@ redef class ModelBuilder # 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 @@ -92,12 +147,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 +162,59 @@ 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 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 if m2m.keys.has(m) then + var amodule = m2m[m] + if m.uses_ffi or amodule.uses_legacy_ni then + compiler.finalize_ffi_for_module(amodule) + end + 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 +226,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 +257,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 +278,95 @@ 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 if m2m.keys.has(m) then + var amod = m2m[m] + linker_options.add(amod.c_linker_options) + end + + if not toolcontext.opt_no_stacktrace.value 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") 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) - # 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) + if f isa ExternCFile then + var basename = f.filename.basename(".c") + var o = "{basename}.extern.o" + var ff = f.filename.basename("") + makefile.write("{o}: {ff}\n\t$(CC) $(CFLAGS) -D NONITCNI {f.cflags} -c -o {o} {ff}\n\n") + ofiles.add(o) + dep_rules.add(o) + else + 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 isa ExternCppFile then ofiles.add(o) + end 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 +374,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 +427,69 @@ 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_fun_names") + stream.write("%\{\n#include \"c_functions_hash.h\"\n%\}\n") + stream.write("%define lookup-function-name get_nit_name\n") + stream.write("struct C_Nit_Names;\n") + stream.write("%%\n") + stream.write("####\n") + for i in names.keys do + stream.write(i) + stream.write(",\t\"") + stream.write(names[i]) + stream.write("\"\n") + end + stream.write("####\n") + stream.write("%%\n") + stream.close + + stream = new OFStream.open("{compile_dir}/c_functions_hash.h") + stream.write("typedef struct C_Nit_Names\{char* name; char* nit_name;\}C_Nit_Names;\n") + stream.write("const struct C_Nit_Names* get_nit_name(register const char *str, register unsigned int len);\n") + stream.close + + var x = new Process("gperf","{compile_dir}/C_fun_names","-t","-7","--output-file={compile_dir}/c_functions_hash.c","-C") + x.wait + + 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 + + # Signal handler function prototype + self.header.add_decl("void show_backtrace(int);") - # 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 +498,14 @@ abstract class AbstractCompiler fun compile_main_function do var v = self.new_visitor + if modelbuilder.toolcontext.opt_stacktrace.value then + v.add_decl("#include \"c_functions_hash.h\"") + end + v.add_decl("#include ") + if not modelbuilder.toolcontext.opt_no_stacktrace.value then + v.add_decl("#define UNW_LOCAL_ONLY") + v.add_decl("#include ") + end v.add_decl("int glob_argc;") v.add_decl("char **glob_argv;") v.add_decl("val *glob_sys;") @@ -337,7 +520,55 @@ abstract class AbstractCompiler v.compiler.header.add_decl("extern long count_type_test_skipped_{tag};") end 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 not modelbuilder.toolcontext.opt_no_stacktrace.value 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 modelbuilder.toolcontext.opt_stacktrace.value then + v.add_decl(" const C_Nit_Names* recv = get_nit_name(procname, strlen(procname));") + v.add_decl(" if (recv != 0)\{") + v.add_decl(" printf(\"` %s\\n\", recv->nit_name);") + 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 +611,20 @@ 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 + 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 @@ -484,6 +716,13 @@ abstract class AbstractCompiler if b == 0 then return "n/a" return ((a*10000/b).to_f / 100.0).to_precision(2) end + + fun finalize_ffi_for_module(nmodule: AModule) + do + var visitor = new_visitor + nmodule.finalize_ffi(visitor, modelbuilder) + nmodule.finalize_nitni(visitor) + end end # A file unit (may be more than one file if @@ -614,7 +853,7 @@ 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` + # ENSURE: `result.name == value.name` fun autoadapt(value: RuntimeVariable, mtype: MType): RuntimeVariable do mtype = self.anchor(mtype) @@ -638,7 +877,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 @@ -666,6 +905,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 @@ -687,14 +934,11 @@ 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_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] @@ -807,13 +1051,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 +1079,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 @@ -855,11 +1101,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 @@ -869,8 +1117,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`. @@ -885,12 +1134,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 (!{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` @@ -924,10 +1190,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 @@ -1057,71 +1320,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*" @@ -1332,10 +1530,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 @@ -1362,13 +1557,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) @@ -1465,7 +1660,7 @@ 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 v.ret(v.new_expr("{arguments[0]} + {arguments[1]}", ret.as(not null))) @@ -1510,7 +1705,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 +1766,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 +1802,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});") @@ -1655,7 +1835,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) @@ -1687,7 +1867,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) @@ -1778,7 +1958,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 @@ -2006,29 +2190,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 +2222,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 @@ -2077,6 +2261,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,15 +2314,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 @@ -2175,8 +2365,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 +2377,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 +2408,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 @@ -2307,22 +2492,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 +2538,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 @@ -2436,3 +2624,14 @@ redef class MModule end private var properties_cache: Map[MClass, Set[MProperty]] = new HashMap[MClass, Set[MProperty]] end + +redef class AModule + # Does this module use the legacy native interface? + fun uses_legacy_ni: Bool is abstract + + # Write FFI results to file + fun finalize_ffi(v: AbstractCompilerVisitor, modelbuilder: ModelBuilder) is abstract + + # Write nitni results to file + fun finalize_nitni(v: AbstractCompilerVisitor) is abstract +end