do
# Collect all bas box class
# FIXME: this is not completely fine with a separate compilation scheme
- for classname in ["Int", "Bool", "Char", "Float", "NativeString", "Pointer"] do
+ for classname in ["Int", "Bool", "Byte", "Char", "Float", "NativeString", "Pointer"] do
var classes = self.mainmodule.model.get_mclasses_by_name(classname)
if classes == null then continue
assert classes.length == 1 else print classes.join(", ")
var mtypes_by_class = new MultiHashMap[MClass, MType]
for e in mtypes do
- var c = e.as_notnullable.as(MClassType).mclass
+ var c = e.undecorate.as(MClassType).mclass
mtypes_by_class[c].add(e)
poset.add_node(e)
end
var casttypes_by_class = new MultiHashMap[MClass, MType]
for e in cast_types do
- var c = e.as_notnullable.as(MClassType).mclass
+ var c = e.undecorate.as(MClassType).mclass
casttypes_by_class[c].add(e)
poset.add_node(e)
end
# Group cast_type by their classes
var bucklets = new HashMap[MClass, Set[MType]]
for e in cast_types do
- var c = e.as_notnullable.as(MClassType).mclass
+ var c = e.undecorate.as(MClassType).mclass
if not bucklets.has_key(c) then
bucklets[c] = new HashSet[MType]
end
for cd in mmodule.mclassdefs do
for pd in cd.mpropdefs do
if not pd isa MMethodDef then continue
+ if pd.msignature == null then continue # Skip broken method
var rta = runtime_type_analysis
if modelbuilder.toolcontext.opt_skip_dead_methods.value and rta != null and not rta.live_methoddefs.has(pd) then continue
#print "compile {pd} @ {cd} @ {mmodule}"
# resolution table (for receiver)
if is_live then
- var mclass_type = mtype.as_notnullable
+ var mclass_type = mtype.undecorate
assert mclass_type isa MClassType
if resolution_tables[mclass_type].is_empty then
v.add_decl("NULL, /*NO RESOLUTIONS*/")
end
v.add_decl("\},")
else
- v.add_decl("0, \{\}, /*DEAD TYPE*/")
+ # Use -1 to indicate dead type, the info is used by --hardening
+ v.add_decl("-1, \{\}, /*DEAD TYPE*/")
end
v.add_decl("\};")
end
fun compile_type_resolution_table(mtype: MType) do
- var mclass_type = mtype.as_notnullable.as(MClassType)
+ var mclass_type = mtype.undecorate.as(MClassType)
# extern const struct resolution_table_X resolution_table_X
self.provide_declaration("resolution_table_{mtype.c_name}", "extern const struct types resolution_table_{mtype.c_name};")
var v = new_visitor
var rta = runtime_type_analysis
- var is_dead = rta != null and not rta.live_classes.has(mclass) and not mtype.is_c_primitive and mclass.name != "NativeArray" and mclass.name != "Pointer"
+ var is_dead = rta != null and not rta.live_classes.has(mclass)
+ # While the class may be dead, some part of separately compiled code may use symbols associated to the class, so
+ # in order to compile and link correctly the C code, these symbols should be declared and defined.
+ var need_corpse = is_dead and mtype.is_c_primitive or mclass.kind == extern_kind or mclass.kind == enum_kind
- v.add_decl("/* runtime class {c_name} */")
+ v.add_decl("/* runtime class {c_name}: {mclass.full_name} (dead={is_dead}; need_corpse={need_corpse})*/")
# Build class vft
- if not is_dead then
+ if not is_dead or need_corpse then
self.provide_declaration("class_{c_name}", "extern const struct class class_{c_name};")
v.add_decl("const struct class class_{c_name} = \{")
v.add_decl("{self.box_kind_of(mclass)}, /* box_kind */")
self.header.add_decl("{mtype.ctype_extern} value;")
self.header.add_decl("\};")
- if not rta.live_types.has(mtype) and mtype.mclass.name != "Pointer" then return
+ # Pointer is needed by extern types, live or not
+ if is_dead and mtype.mclass.name != "Pointer" then return
#Build BOX
self.provide_declaration("BOX_{c_name}", "val* BOX_{c_name}({mtype.ctype_extern});")
v.add("return (val*)res;")
v.add("\}")
+ # A Pointer class also need its constructor
if mtype.mclass.name != "Pointer" then return
v = new_visitor
var pointer_type = mainmodule.pointer_type
self.provide_declaration("NEW_{c_name}", "{mtype.ctype} NEW_{c_name}(const struct type* type);")
- v.add_decl("/* allocate {mtype} */")
+ v.add_decl("/* allocate extern {mtype} */")
v.add_decl("{mtype.ctype} NEW_{c_name}(const struct type* type) \{")
if is_dead then
v.add_abort("{mclass} is DEAD")
v.add("if({t} == NULL) \{")
v.add_abort("type null")
v.add("\}")
- v.add("if({t}->table_size == 0) \{")
+ v.add("if({t}->table_size < 0) \{")
v.add("PRINT_ERROR(\"Insantiation of a dead type: %s\\n\", {t}->name);")
v.add_abort("type dead")
v.add("\}")
if mtype.name == "Int" then
return self.new_expr("(long)({value})>>2", mtype)
else if mtype.name == "Char" then
- return self.new_expr("(char)((long)({value})>>2)", mtype)
+ return self.new_expr("(uint32_t)((long)({value})>>2)", mtype)
else if mtype.name == "Bool" then
return self.new_expr("(short int)((long)({value})>>2)", mtype)
else
valtype = compiler.mainmodule.pointer_type
end
var res = self.new_var(mtype)
- if compiler.runtime_type_analysis != null and not compiler.runtime_type_analysis.live_types.has(valtype) then
- self.add("/*no autobox from {value.mtype} to {mtype}: {value.mtype} is not live! */")
- self.add("PRINT_ERROR(\"Dead code executed!\\n\"); fatal_exit(1);")
- return res
- end
self.require_declaration("BOX_{valtype.c_name}")
self.add("{res} = BOX_{valtype.c_name}({value}); /* autobox from {value.mtype} to {mtype} */")
return res
mtype.mclass.name != "NativeString" then
var valtype = compiler.mainmodule.pointer_type
var res = self.new_var(mtype)
- if compiler.runtime_type_analysis != null and not compiler.runtime_type_analysis.live_types.has(value.mtype.as(MClassType)) then
- self.add("/*no boxing of {value.mtype}: {value.mtype} is not live! */")
- self.add("PRINT_ERROR(\"Dead code executed!\\n\"); fatal_exit(1);")
- return res
- end
+ compiler.undead_types.add(mtype)
self.require_declaration("BOX_{valtype.c_name}")
self.add("{res} = BOX_{valtype.c_name}({value}); /* boxing {value.mtype} */")
self.require_declaration("type_{mtype.c_name}")
if compiler.modelbuilder.toolcontext.opt_invocation_metrics.value then add("count_invoke_by_tables++;")
assert arguments.length == mmethod.intro.msignature.arity + 1 else debug("Invalid arity for {mmethod}. {arguments.length} arguments given.")
- var recv = arguments.first
var res0 = before_send(mmethod, arguments)
var runtime_function = mmethod.intro.virtual_runtime_function
var msignature = runtime_function.called_signature
+ adapt_signature(mmethod.intro, arguments)
+
var res: nullable RuntimeVariable
var ret = msignature.return_mtype
if ret == null then
res = self.new_var(ret)
end
- var ss = new FlatBuffer
-
- ss.append("{recv}")
- for i in [0..msignature.arity[ do
- var a = arguments[i+1]
- var t = msignature.mparameters[i].mtype
- if i == msignature.vararg_rank then
- t = arguments[i+1].mcasttype
- end
- a = self.autobox(a, t)
- ss.append(", {a}")
- end
+ var ss = arguments.join(", ")
var const_color = mentity.const_color
var ress
fun can_be_primitive(value: RuntimeVariable): Bool
do
- var t = value.mcasttype.as_notnullable
+ var t = value.mcasttype.undecorate
if not t isa MClassType then return false
var k = t.mclass.kind
return k == interface_kind or t.is_c_primitive
self.require_declaration("NEW_{mtype.mclass.c_name}")
assert mtype isa MGenericType
var compiler = self.compiler
+ length = autobox(length, compiler.mainmodule.int_type)
if mtype.need_anchor then
hardening_live_open_type(mtype)
link_unresolved_type(self.frame.mpropdef.mclassdef, mtype)
# The C type for the function pointer.
var c_funptrtype: String is lazy do return "{c_ret}(*){c_sig}"
- # The arguments, as generated by `compile_to_c`
- private var arguments: Array[RuntimeVariable] is noinit
-
redef fun compile_to_c(compiler)
do
var mmethoddef = self.mmethoddef
+ var sig = "{c_ret} {c_name}{c_sig}"
+ compiler.provide_declaration(self.c_name, "{sig} __attribute__((weak));")
+
+ var rta = compiler.as(SeparateCompiler).runtime_type_analysis
+ if rta != null and not rta.live_mmodules.has(mmethoddef.mclassdef.mmodule) then
+ return
+ end
+
var recv = self.mmethoddef.mclassdef.bound_mtype
var v = compiler.new_visitor
var selfvar = new RuntimeVariable("self", called_recv, recv)
var msignature = called_signature
var ret = called_signature.return_mtype
- var sig = new FlatBuffer
var comment = new FlatBuffer
- sig.append(c_ret)
- sig.append(" ")
- sig.append(self.c_name)
- sig.append(c_sig)
comment.append("({selfvar}: {selfvar.mtype}")
arguments.add(selfvar)
for i in [0..msignature.arity[ do
if ret != null then
comment.append(": {ret}")
end
- compiler.provide_declaration(self.c_name, "{sig};")
- self.arguments = arguments.to_a
v.add_decl("/* method {self} for {comment} */")
v.add_decl("{sig} \{")
fun compile_trampolines(compiler: SeparateCompiler)
do
var recv = self.mmethoddef.mclassdef.bound_mtype
- var selfvar = arguments.first
+ var selfvar = new RuntimeVariable("self", called_recv, recv)
var ret = called_signature.return_mtype
+ var arguments = ["self"]
+ for i in [0..called_signature.arity[ do arguments.add "p{i}"
if mmethoddef.is_intro and not recv.is_c_primitive then
var m = mmethoddef.mproperty