# --hardening
var opt_hardening: OptionBool = new OptionBool("Generate contracts in the C code against bugs in the compiler", "--hardening")
+ # --no-shortcut-range
+ 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-other
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")
+
redef init
do
super
- self.option_context.add_option(self.opt_output, self.opt_no_cc, self.opt_make_flags, self.opt_hardening)
+ 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_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)
end
end
self.toolcontext.info("*** COMPILING TO C ***", 1)
var compiler = new GlobalCompiler(mainmodule, runtime_type_analysis, self)
+ compiler.compile_header
var v = compiler.header
for t in runtime_type_analysis.live_types do
end
self.toolcontext.info("Total methods to compile to C: {compiler.visitors.length}", 2)
+ compiler.display_stats
+
var time1 = get_time
self.toolcontext.info("*** END VISITING: {time1-time0} ***", 2)
write_and_make(compiler)
var i = 0
for vis in compiler.visitors do
count += vis.lines.length
- if file == null or count > 10000 then
+ if file == null or count > 10000 or vis.file_break then
i += 1
if file != null then file.close
var cfilename = ".nit_compile/{mainmodule.name}.{i}.c"
self.live_primitive_types.add(t)
end
end
+ end
- # Header declarations
- self.compile_header
+ # Force the creation of a new file
+ # The point is to avoid contamination between must-be-compiled-separately files
+ fun new_file
+ do
+ var v = self.new_visitor
+ v.file_break = true
end
- protected fun compile_header do
+ fun compile_header do
var v = self.header
self.header.add_decl("#include <stdlib.h>")
self.header.add_decl("#include <stdio.h>")
self.header.add_decl("#include <string.h>")
self.header.add_decl("#ifndef NOBOEHM")
self.header.add_decl("#include <gc/gc.h>")
+ self.header.add_decl("#ifdef NOBOEHM_ATOMIC")
+ self.header.add_decl("#undef GC_MALLOC_ATOMIC")
+ self.header.add_decl("#define GC_MALLOC_ATOMIC(x) GC_MALLOC(x)")
+ self.header.add_decl("#endif /*NOBOEHM_ATOMIC*/")
self.header.add_decl("#else /*NOBOEHM*/")
self.header.add_decl("#define GC_MALLOC(x) calloc(1, (x))")
+ self.header.add_decl("#define GC_MALLOC_ATOMIC(x) calloc(1, (x))")
self.header.add_decl("#endif /*NOBOEHM*/")
compile_header_structs
# Initialize a visitor specific for a compiler engine
fun new_visitor: GlobalCompilerVisitor do return new GlobalCompilerVisitor(self)
+ var count_type_test_tags: Array[String] = ["isa", "as", "auto", "covariance", "erasure"]
+ var count_type_test_resolved: HashMap[String, Int] = init_count_type_test_tags
+ var count_type_test_unresolved: HashMap[String, Int] = init_count_type_test_tags
+ var count_type_test_skipped: HashMap[String, Int] = init_count_type_test_tags
+
+ private fun init_count_type_test_tags: HashMap[String, Int]
+ do
+ var res = new HashMap[String, Int]
+ for tag in count_type_test_tags do
+ res[tag] = 0
+ end
+ return res
+ end
+
# Generate the main C function.
# This function:
# allocate the Sys object if it exists
v.add_decl("int glob_argc;")
v.add_decl("char **glob_argv;")
v.add_decl("val *glob_sys;")
+
+ if self.modelbuilder.toolcontext.opt_typing_test_metrics.value then
+ for tag in count_type_test_tags do
+ v.add_decl("long count_type_test_resolved_{tag};")
+ v.add_decl("long count_type_test_unresolved_{tag};")
+ v.add_decl("long count_type_test_skipped_{tag};")
+ v.compiler.header.add_decl("extern long count_type_test_resolved_{tag};")
+ v.compiler.header.add_decl("extern long count_type_test_unresolved_{tag};")
+ v.compiler.header.add_decl("extern long count_type_test_skipped_{tag};")
+ end
+ end
v.add_decl("int main(int argc, char** argv) \{")
v.add("glob_argc = argc; glob_argv = argv;")
var main_type = mainmodule.sys_type
v.send(main_method, [glob_sys])
end
end
+
+ if self.modelbuilder.toolcontext.opt_typing_test_metrics.value then
+ v.add_decl("long count_type_test_resolved_total = 0;")
+ v.add_decl("long count_type_test_unresolved_total = 0;")
+ v.add_decl("long count_type_test_skipped_total = 0;")
+ v.add_decl("long count_type_test_total_total = 0;")
+ for tag in count_type_test_tags do
+ v.add_decl("long count_type_test_total_{tag};")
+ v.add("count_type_test_total_{tag} = count_type_test_resolved_{tag} + count_type_test_unresolved_{tag} + count_type_test_skipped_{tag};")
+ v.add("count_type_test_resolved_total += count_type_test_resolved_{tag};")
+ v.add("count_type_test_unresolved_total += count_type_test_unresolved_{tag};")
+ v.add("count_type_test_skipped_total += count_type_test_skipped_{tag};")
+ v.add("count_type_test_total_total += count_type_test_total_{tag};")
+ end
+ v.add("printf(\"# dynamic count_type_test: total %l\\n\");")
+ v.add("printf(\"\\tresolved\\tunresolved\\tskipped\\ttotal\\n\");")
+ var tags = count_type_test_tags.to_a
+ tags.add("total")
+ for tag in tags do
+ v.add("printf(\"{tag}\");")
+ v.add("printf(\"\\t%ld (%.2f%%)\", count_type_test_resolved_{tag}, 100.0*count_type_test_resolved_{tag}/count_type_test_total_total);")
+ v.add("printf(\"\\t%ld (%.2f%%)\", count_type_test_unresolved_{tag}, 100.0*count_type_test_unresolved_{tag}/count_type_test_total_total);")
+ v.add("printf(\"\\t%ld (%.2f%%)\", count_type_test_skipped_{tag}, 100.0*count_type_test_skipped_{tag}/count_type_test_total_total);")
+ 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
+ fun div(a,b:Int):String
+ do
+ if b == 0 then return "n/a"
+ return ((a*10000/b).to_f / 100.0).to_precision(2)
+ end
+
+ fun display_stats
+ do
+ if self.modelbuilder.toolcontext.opt_typing_test_metrics.value then
+ print "# static count_type_test"
+ print "\tresolved:\tunresolved\tskipped\ttotal"
+ var count_type_test_total = init_count_type_test_tags
+ count_type_test_resolved["total"] = 0
+ count_type_test_unresolved["total"] = 0
+ count_type_test_skipped["total"] = 0
+ count_type_test_total["total"] = 0
+ for tag in count_type_test_tags do
+ count_type_test_total[tag] = count_type_test_resolved[tag] + count_type_test_unresolved[tag] + count_type_test_skipped[tag]
+ count_type_test_resolved["total"] += count_type_test_resolved[tag]
+ count_type_test_unresolved["total"] += count_type_test_unresolved[tag]
+ count_type_test_skipped["total"] += count_type_test_skipped[tag]
+ count_type_test_total["total"] += count_type_test_total[tag]
+ end
+ var count_type_test = count_type_test_total["total"]
+ var tags = count_type_test_tags.to_a
+ tags.add("total")
+ for tag in tags do
+ printn tag
+ printn "\t{count_type_test_resolved[tag]} ({div(count_type_test_resolved[tag],count_type_test)}%)"
+ printn "\t{count_type_test_unresolved[tag]} ({div(count_type_test_unresolved[tag],count_type_test)}%)"
+ printn "\t{count_type_test_skipped[tag]} ({div(count_type_test_skipped[tag],count_type_test)}%)"
+ printn "\t{count_type_test_total[tag]} ({div(count_type_test_total[tag],count_type_test)}%)"
+ print ""
+ end
+ end
+ end
+
private var collect_types_cache: HashMap[MType, Array[MClassType]] = new HashMap[MType, Array[MClassType]]
end
return "val*"
end
+ fun ctypename: String
+ do
+ return "val"
+ end
+
# Return the name of the C structure associated to a Nit live type
# FIXME: move to GlobalCompiler so we can check that self is a live type
fun c_name: String is abstract
return "val*"
end
end
+
+ redef fun ctypename: String
+ do
+ if mclass.name == "Int" then
+ return "l"
+ else if mclass.name == "Bool" then
+ return "s"
+ else if mclass.name == "Char" then
+ return "c"
+ else if mclass.name == "Float" then
+ return "d"
+ else if mclass.name == "NativeString" then
+ return "str"
+ else if mclass.name == "NativeArray" then
+ #return "{self.arguments.first.ctype}*"
+ return "val"
+ else if mclass.kind == extern_kind then
+ return "ptr"
+ else
+ return "val"
+ end
+ end
end
redef class MGenericType
compiler.visitors.add(self)
end
+ var file_break: Bool = false
+
# Alias for self.compiler.mainmodule.object_type
fun object_type: MClassType do return self.compiler.mainmodule.object_type
mtype = self.anchor(mtype)
res = self.autobox(res, mtype)
end
+ 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)
+ var castres = self.type_test(res, implicit_cast_to, "auto")
self.add("if (!{castres}) \{")
self.add_abort("Cast failed")
self.add("\}")
+ res = autoadapt(res, implicit_cast_to)
end
self.current_node = old
return res
self.add("/* skip, no method {m} */")
return res
end
- var propdefs = m.lookup_definitions(self.compiler.mainmodule, mclasstype)
- if propdefs.length == 0 then
- self.add("/* skip, no method {m} */")
- return res
- end
- assert propdefs.length == 1
- var propdef = propdefs.first
+ var propdef = m.lookup_first_definition(self.compiler.mainmodule, mclasstype)
var res2 = self.call(propdef, mclasstype, args)
if res != null then self.assign(res, res2.as(not null))
return res
var last = types.last
var defaultpropdef: nullable MMethodDef = null
for t in types do
- var propdefs = m.lookup_definitions(self.compiler.mainmodule, t)
- if propdefs.length == 0 then
- self.add("/* skip {t}, no method {m} */")
- continue
- end
- if propdefs.length > 1 then
- self.debug("NOT YET IMPLEMENTED conflict for {t}.{m}: {propdefs.join(" ")}. choose the first")
- end
- var propdef = propdefs.first
+ var propdef = m.lookup_first_definition(self.compiler.mainmodule, t)
if propdef.mclassdef.mclass.name == "Object" and t.ctype == "val*" then
defaultpropdef = propdef
continue
fun monomorphic_send(m: MMethod, t: MType, args: Array[RuntimeVariable]): nullable RuntimeVariable
do
assert t isa MClassType
- var propdefs = m.lookup_definitions(self.compiler.mainmodule, t)
- if propdefs.length == 0 then
- abort
- end
- if propdefs.length > 1 then
- self.debug("NOT YET IMPLEMENTED conflict for {t}.{m}: {propdefs.join(" ")}. choose the first")
- end
- var propdef = propdefs.first
+ var propdef = m.lookup_first_definition(self.compiler.mainmodule, t)
return self.call(propdef, t, args)
end
end
# Generate a polymorphic subtype test
- fun type_test(value: RuntimeVariable, mtype: MType): RuntimeVariable
+ fun type_test(value: RuntimeVariable, mtype: MType, tag: String): RuntimeVariable
do
mtype = self.anchor(mtype)
var mclasstype = mtype
# 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)
+ var cond = v.type_test(arguments[i+1], mtype, "covariance")
v.add("if (!{cond}) \{")
#var x = v.class_name_string(arguments[i+1])
#var y = v.class_name_string(arguments.first)
v.ret(v.new_expr("glob_sys", ret.as(not null)))
return
else if pname == "calloc_string" then
- v.ret(v.new_expr("(char*)GC_MALLOC({arguments[1]})", ret.as(not null)))
+ v.ret(v.new_expr("(char*)GC_MALLOC_ATOMIC({arguments[1]})", ret.as(not null)))
return
else if pname == "calloc_array" then
v.calloc_array(ret.as(not null), arguments)
redef class AForExpr
redef fun stmt(v)
do
+ # Shortcut on explicit range
+ # Avoid the instantiation of the range and the iterator
+ var nexpr = self.n_expr
+ if self.variables.length == 1 and nexpr isa AOrangeExpr and not v.compiler.modelbuilder.toolcontext.opt_no_shortcut_range.value then
+ var from = v.expr(nexpr.n_expr, null)
+ var to = v.expr(nexpr.n_expr2, null)
+ var variable = v.variable(variables.first)
+
+ v.assign(variable, from)
+ v.add("for(;;) \{ /* shortcut range */")
+
+ var ok = v.send(v.get_property("<", variable.mtype), [variable, to])
+ assert ok != null
+ v.add("if(!{ok}) break;")
+
+ v.stmt(self.n_block)
+
+ v.add("CONTINUE_{v.escapemark_name(escapemark)}: (void)0;")
+ var succ = v.send(v.get_property("succ", variable.mtype), [variable])
+ assert succ != null
+ v.assign(variable, succ)
+ v.add("\}")
+ v.add("BREAK_{v.escapemark_name(escapemark)}: (void)0;")
+ return
+ end
+
var cl = v.expr(self.n_expr, null)
var it_meth = self.method_iterator
assert it_meth != null
redef fun expr(v)
do
var i = v.expr(self.n_expr, null)
- return v.type_test(i, self.cast_type.as(not null))
+ return v.type_test(i, self.cast_type.as(not null), "isa")
end
end
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))
+ var cond = v.type_test(i, self.mtype.as(not null), "as")
v.add("if (!{cond}) \{")
v.add_abort("Cast failed")
v.add("\}")
nitlanguage / nit.git / blobdiff