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
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
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)
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
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]
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
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 <stdlib.h>")
self.header.add_decl("#include <stdio.h>")
self.header.add_decl("#include <string.h>")
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;")
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 <signal.h>")
+ if not modelbuilder.toolcontext.opt_no_stacktrace.value then
+ v.add_decl("#define UNW_LOCAL_ONLY")
+ v.add_decl("#include <libunwind.h>")
+ end
v.add_decl("int glob_argc;")
v.add_decl("char **glob_argv;")
v.add_decl("val *glob_sys;")
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
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
# 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
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
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]
else
self.add("fprintf(stderr, \"\\n\");")
end
- self.add("exit(1);")
+ self.add("show_backtrace(1);")
end
# Add a dynamic cast
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)
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)
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
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
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
#self.debug("got {res2} from {mproperty}. drop {recv}")
return res2
end
- v.check_init_instance(recv, mtype)
return recv
end
end
nitlanguage / nit.git / blobdiff