X-Git-Url: http://nitlanguage.org diff --git a/src/compiler/separate_compiler.nit b/src/compiler/separate_compiler.nit index 9626ac7..f6c483c 100644 --- a/src/compiler/separate_compiler.nit +++ b/src/compiler/separate_compiler.nit @@ -26,20 +26,20 @@ redef class ToolContext # --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") @@ -48,9 +48,9 @@ redef class ToolContext # --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 @@ -60,7 +60,7 @@ redef class ToolContext # --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 @@ -626,7 +626,7 @@ class SeparateCompiler 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}" @@ -814,6 +814,8 @@ class SeparateCompiler # 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 @@ -843,6 +845,9 @@ class SeparateCompiler 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) @@ -1861,7 +1866,7 @@ class SeparateCompilerVisitor 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 */") @@ -1894,20 +1899,58 @@ class SeparateCompilerVisitor 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