X-Git-Url: http://nitlanguage.org diff --git a/src/abstract_compiler.nit b/src/abstract_compiler.nit index 857cb37..62f7ec7 100644 --- a/src/abstract_compiler.nit +++ b/src/abstract_compiler.nit @@ -50,6 +50,10 @@ 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 @@ -57,6 +61,8 @@ redef class ToolContext 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 @@ -87,6 +93,11 @@ redef class ModelBuilder toolcontext.error(null, "Cannot determine the nit clib path. define envvar NIT_DIR.") end + 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 + # Add user defined cc_paths cc_paths.append(toolcontext.opt_cc_path.value) @@ -111,6 +122,9 @@ redef class ModelBuilder if compile_dir == null then compile_dir = ".nit_compile" compile_dir.mkdir + + if self.toolcontext.opt_stacktrace.value then compiler.build_c_to_nit_bindings + var orig_dir=".." # FIXME only works if `compile_dir` is a subdirectory of cwd var outname = self.toolcontext.opt_output.value @@ -193,7 +207,11 @@ redef class ModelBuilder 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") + if toolcontext.opt_no_stacktrace.value then + makefile.write("CC = ccache cc\nCFLAGS = -g -O2\nCINCL = {cc_includes}\nLDFLAGS ?= \nLDLIBS ?= -lm -lgc\n\n") + else + makefile.write("CC = ccache cc\nCFLAGS = -g -O2\nCINCL = {cc_includes}\nLDFLAGS ?= \nLDLIBS ?= -lunwind -lm -lgc\n\n") + end makefile.write("all: {outpath}\n\n") var ofiles = new Array[String] @@ -256,6 +274,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,10 +327,45 @@ abstract class AbstractCompiler private var provided_declarations = new HashMap[String, String] + # 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.toolcontext.opt_compile_dir.value + if compile_dir == null then compile_dir = ".nit_compile" + + 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 ") @@ -317,6 +373,9 @@ abstract class AbstractCompiler compile_header_structs + # Signal handler function prototype + self.header.add_decl("void show_backtrace(int);") + # Global variable used by the legacy native interface self.header.add_decl("extern int glob_argc;") self.header.add_decl("extern char **glob_argv;") @@ -334,6 +393,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;") @@ -348,7 +415,49 @@ abstract class AbstractCompiler v.compiler.header.add_decl("extern long count_type_test_skipped_{tag};") end end + + 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, show_backtrace);") + v.add("signal(SIGFPE, show_backtrace);") + v.add("signal(SIGILL, show_backtrace);") + v.add("signal(SIGINT, show_backtrace);") + v.add("signal(SIGTERM, show_backtrace);") + v.add("signal(SIGSEGV, show_backtrace);") + v.add("glob_argc = argc; glob_argv = argv;") v.add("initialize_gc_option();") var main_type = mainmodule.sys_type @@ -391,6 +500,7 @@ 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 @@ -401,9 +511,6 @@ abstract class AbstractCompiler # 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 @@ -677,6 +784,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 @@ -703,9 +818,6 @@ abstract class AbstractCompilerVisitor 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] @@ -894,12 +1006,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` @@ -933,10 +1062,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 @@ -1284,10 +1410,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 @@ -1559,6 +1682,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 +1715,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 +1747,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 +1838,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 @@ -2064,15 +2194,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 @@ -2125,7 +2246,6 @@ redef class ACrangeExpr 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) return res end end @@ -2138,7 +2258,6 @@ redef class AOrangeExpr 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) return res end end @@ -2169,10 +2288,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 @@ -2260,13 +2376,13 @@ redef class ASuperExpr args = v.frame.arguments end - var mproperty = self.mproperty - if mproperty != null then - if mproperty.intro.msignature.arity == 0 then + var callsite = self.callsite + if callsite != null then + if callsite.mproperty.intro.msignature.arity == 0 then args = [recv] end # Super init call - var res = v.send(mproperty, args) + var res = v.compile_callsite(callsite, args) return res end @@ -2298,7 +2414,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