# --no-inline-intern
var opt_no_inline_intern = new OptionBool("Do not inline call to intern methods", "--no-inline-intern")
# --no-union-attribute
- var opt_no_union_attribute = new OptionBool("Put primitive attibutes in a box instead of an union", "--no-union-attribute")
+ var opt_no_union_attribute = new OptionBool("Put primitive attributes in a box instead of an union", "--no-union-attribute")
# --no-shortcut-equate
var opt_no_shortcut_equate = new OptionBool("Always call == in a polymorphic way", "--no-shortcut-equal")
# --no-tag-primitives
var opt_no_tag_primitives = new OptionBool("Use only boxes for primitive types", "--no-tag-primitives")
# --colors-are-symbols
- var opt_colors_are_symbols = new OptionBool("Store colors as symbols (link-boost)", "--colors-are-symbols")
+ var opt_colors_are_symbols = new OptionBool("Store colors as symbols instead of static data (link-boost)", "--colors-are-symbols")
# --trampoline-call
var opt_trampoline_call = new OptionBool("Use an indirection when calling", "--trampoline-call")
# --guard-call
var opt_guard_call = new OptionBool("Guard VFT calls with a direct call", "--guard-call")
# --substitute-monomorph
- var opt_substitute_monomorph = new OptionBool("Replace monomorph trampoline with direct call (link-boost)", "--substitute-monomorph")
+ var opt_substitute_monomorph = new OptionBool("Replace monomorphic trampolines with direct calls (link-boost)", "--substitute-monomorph")
# --link-boost
var opt_link_boost = new OptionBool("Enable all link-boost optimizations", "--link-boost")
# --inline-some-methods
var opt_inline_some_methods = new OptionBool("Allow the separate compiler to inline some methods (semi-global)", "--inline-some-methods")
# --direct-call-monomorph
- var opt_direct_call_monomorph = new OptionBool("Allow the separate compiler to direct call monomorph sites (semi-global)", "--direct-call-monomorph")
+ var opt_direct_call_monomorph = new OptionBool("Allow the separate compiler to direct call monomorphic sites (semi-global)", "--direct-call-monomorph")
# --direct-call-monomorph0
- var opt_direct_call_monomorph0 = new OptionBool("Allow the separate compiler to direct call monomorph sites (semi-global)", "--direct-call-monomorph0")
+ var opt_direct_call_monomorph0 = new OptionBool("Allow the separate compiler to direct call monomorphic sites (semi-global)", "--direct-call-monomorph0")
# --skip-dead-methods
var opt_skip_dead_methods = new OptionBool("Do not compile dead methods (semi-global)", "--skip-dead-methods")
# --semi-global
# --tables-metrics
var opt_tables_metrics = new OptionBool("Enable static size measuring of tables used for vft, typing and resolution", "--tables-metrics")
# --type-poset
- var opt_type_poset = new OptionBool("Build a poset of types to create more condensed tables.", "--type-poset")
+ var opt_type_poset = new OptionBool("Build a poset of types to create more condensed tables", "--type-poset")
redef init
do
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
+ if pd.mproperty.is_broken or pd.is_broken or 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}"
# In a true separate compiler (a with dynamic loading) you cannot do this unfortnally
fun compile_class_to_c(mclass: MClass)
do
+ if mclass.is_broken then return
+
var mtype = mclass.intro.bound_mtype
var c_name = mclass.c_name
if rta != null and not rta.live_methoddefs.has(mpropdef) then
v.add_decl("NULL, /* DEAD {mclass.intro_mmodule}:{mclass}:{mpropdef} */")
continue
+ else if mpropdef.is_broken or mpropdef.msignature == null or mpropdef.mproperty.is_broken then
+ v.add_decl("NULL, /* DEAD (BROKEN) {mclass.intro_mmodule}:{mclass}:{mpropdef} */")
+ continue
end
var rf = mpropdef.virtual_runtime_function
v.require_declaration(rf.c_name)
# 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
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
# 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