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", "Int8", "Int16", "UInt16", "Int32", "UInt32"] 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")
# use some Huffman coding.
if t.name == "Int" then
class_info[1] = t
+ t.mclass_type.tag_value = 1
else if t.name == "Char" then
class_info[2] = t
+ t.mclass_type.tag_value = 2
else if t.name == "Bool" then
class_info[3] = t
+ t.mclass_type.tag_value = 3
else
continue
end
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
end
return self.new_expr("((struct instance_{mtype.c_name}*){value})->value; /* autounbox from {value.mtype} to {mtype} */", mtype)
else if not mtype.is_c_primitive then
+ assert value.mtype == value.mcasttype
if value.mtype.is_tagged then
+ var res
if value.mtype.name == "Int" then
- return self.new_expr("(val*)({value}<<2|1)", mtype)
+ res = self.new_expr("(val*)({value}<<2|1)", mtype)
else if value.mtype.name == "Char" then
- return self.new_expr("(val*)((long)({value})<<2|2)", mtype)
+ res = self.new_expr("(val*)((long)({value})<<2|2)", mtype)
else if value.mtype.name == "Bool" then
- return self.new_expr("(val*)((long)({value})<<2|3)", mtype)
+ res = self.new_expr("(val*)((long)({value})<<2|3)", mtype)
else
abort
end
+ # Do not loose type info
+ res.mcasttype = value.mcasttype
+ return res
end
var valtype = value.mtype.as(MClassType)
if mtype isa MClassType and mtype.mclass.kind == extern_kind and mtype.mclass.name != "NativeString" then
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
+ # Do not loose type info
+ res.mcasttype = value.mcasttype
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
else
var mtype1 = value1.mtype.as(MClassType)
self.require_declaration("class_{mtype1.c_name}")
- self.add("{res} = ({value2} != NULL) && ({value2}->class == &class_{mtype1.c_name}); /* is_same_type_test */")
+ self.add("{res} = ({value2} != NULL) && ({class_info(value2)} == &class_{mtype1.c_name}); /* is_same_type_test */")
end
else
self.add("{res} = ({value1} == {value2}) || ({value1} != NULL && {value2} != NULL && {class_info(value1)} == {class_info(value2)}); /* is_same_type_test */")
value2 = tmp
end
if value1.mtype.is_c_primitive then
- if value2.mtype == value1.mtype then
+ var t1 = value1.mtype
+ assert t1 == value1.mcasttype
+
+ # Fast case: same C type.
+ if value2.mtype == t1 then
+ # Same exact C primitive representation.
self.add("{res} = {value1} == {value2};")
- else if value2.mtype.is_c_primitive then
- self.add("{res} = 0; /* incompatible types {value1.mtype} vs. {value2.mtype}*/")
- else if value1.mtype.is_tagged then
- self.add("{res} = ({value2} != NULL) && ({self.autobox(value2, value1.mtype)} == {value1});")
+ return res
+ end
+
+ # Complex case: value2 has a different representation
+ # Thus, it should be checked if `value2` is type-compatible with `value1`
+ # This compatibility is done statically if possible and dynamically else
+
+ # Conjunction (ands) of dynamic tests according to the static knowledge
+ var tests = new Array[String]
+
+ var t2 = value2.mcasttype
+ if t2 isa MNullableType then
+ # The destination type cannot be null
+ tests.add("({value2} != NULL)")
+ t2 = t2.mtype
+ else if t2 isa MNullType then
+ # `value2` is known to be null, thus incompatible with a primitive
+ self.add("{res} = 0; /* incompatible types {t1} vs. {t2}*/")
+ return res
+ end
+
+ if t2 == t1 then
+ # Same type but different representation.
+ else if t2.is_c_primitive then
+ # Type of `value2` is a different primitive type, thus incompatible
+ self.add("{res} = 0; /* incompatible types {t1} vs. {t2}*/")
+ return res
+ else if t1.is_tagged then
+ # To be equal, `value2` should also be correctly tagged
+ tests.add("({extract_tag(value2)} == {t1.tag_value})")
else
- var mtype1 = value1.mtype.as(MClassType)
- self.require_declaration("class_{mtype1.c_name}")
- self.add("{res} = ({value2} != NULL) && ({value2}->class == &class_{mtype1.c_name});")
- self.add("if ({res}) \{")
- self.add("{res} = ({self.autobox(value2, value1.mtype)} == {value1});")
- self.add("\}")
+ # To be equal, `value2` should also be boxed with the same class
+ self.require_declaration("class_{t1.c_name}")
+ tests.add "({class_info(value2)} == &class_{t1.c_name})"
+ end
+
+ # Compare the unboxed `value2` with `value1`
+ if tests.not_empty then
+ self.add "if ({tests.join(" && ")}) \{"
end
+ self.add "{res} = {self.autobox(value2, t1)} == {value1};"
+ if tests.not_empty then
+ self.add "\} else {res} = 0;"
+ end
+
return res
end
var maybe_null = true
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};")
+
+ var rta = compiler.as(SeparateCompiler).runtime_type_analysis
+
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} \{")
assert subret != null
v.assign(frame.returnvar.as(not null), subret)
end
+ else if rta != null and not rta.live_mmodules.has(mmethoddef.mclassdef.mmodule) then
+ v.add_abort("FATAL: Dead method executed.")
else
mmethoddef.compile_inside_to_c(v, arguments)
end
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
# Are values of `self` tagged?
# If false, it means that the type is not primitive, or is boxed.
var is_tagged = false
+
+ # The tag value of the type
+ #
+ # ENSURE `is_tagged == (tag_value > 0)`
+ # ENSURE `not is_tagged == (tag_value == 0)`
+ var tag_value = 0
end
redef class MEntity
nitlanguage / nit.git / blobdiff