import auto_super_init
import frontend
import common_ffi
+import platform
# Add compiling options
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")
# --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")
+ # --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_typing_test_metrics, self.opt_invocation_metrics)
self.option_context.add_option(self.opt_stacktrace)
self.option_context.add_option(self.opt_no_stacktrace)
+ self.option_context.add_option(self.opt_no_gcc_directive)
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
# 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
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 not path_env.is_empty then
cc_paths.append(path_env.split_with(':'))
end
-
- var compile_dir = toolcontext.opt_compile_dir.value
- if compile_dir == null then compile_dir = ".nit_compile"
- self.compile_dir = compile_dir
end
- # The compilation directory
- var compile_dir: String
-
- 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
compiler.files_to_copy.add "{cc_paths.first}/gc_chooser.h"
# FFI
- for m in compiler.mainmodule.in_importation.greaters do if mmodule2nmodule.keys.has(m) then
- var amodule = mmodule2nmodule[m]
+ 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
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]
end
var linker_options = new HashSet[String]
- for m in mainmodule.in_importation.greaters do if mmodule2nmodule.keys.has(m) then
- var amod = mmodule2nmodule[m]
+ 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
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
# Compile each required extern body into a specific .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("{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
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
compile_header_structs
compile_nitni_structs
- # Signal handler function prototype
- self.header.add_decl("void show_backtrace(int);")
+ 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 intern methods
self.header.add_decl("extern int glob_argc;")
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 not modelbuilder.toolcontext.opt_no_stacktrace.value then
v.add_decl("char* opt = getenv(\"NIT_NO_STACK\");")
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("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();")
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
nmodule.finalize_ffi(visitor, modelbuilder)
nmodule.finalize_nitni(visitor)
end
-
- # Does this compiler support the FFI?
- fun supports_ffi: Bool do return false
end
# A file unit (may be more than one file if
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
# 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
fun add_cast(value: RuntimeVariable, mtype: MType, tag: String)
do
var res = self.type_test(value, mtype, tag)
- self.add("if (!{res}) \{")
+ 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
var args = [arguments.first]
for auto_super_init in auto_super_inits do
args.clear
- for i in [0..auto_super_init.intro.msignature.arity+1[ do
+ for i in [0..auto_super_init.msignature.arity+1[ do
args.add(arguments[i])
end
- v.send(auto_super_init, args)
+ v.compile_callsite(auto_super_init, args)
end
end
v.stmt(self.n_block)
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
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
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
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])
+ var it = v.compile_callsite(init_callsite.as(not null), [res, i1, i2])
return res
end
end
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])
+ var it = v.compile_callsite(init_callsite.as(not null), [res, i1, i2])
return res
end
end
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
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
nitlanguage / nit.git / blobdiff