FiltrationResult AbstractValue::filter(Graph& graph, const StructureSet& other) { if (isClear()) return FiltrationOK; // FIXME: This could be optimized for the common case of m_type not // having structures, array modes, or a specific value. // https://bugs.webkit.org/show_bug.cgi?id=109663 m_type &= other.speculationFromStructures(); m_arrayModes &= other.arrayModesFromStructures(); m_currentKnownStructure.filter(other); // It's possible that prior to the above two statements we had (Foo, TOP), where // Foo is a SpeculatedType that is disjoint with the passed StructureSet. In that // case, we will now have (None, [someStructure]). In general, we need to make // sure that new information gleaned from the SpeculatedType needs to be fed back // into the information gleaned from the StructureSet. m_currentKnownStructure.filter(m_type); if (m_currentKnownStructure.hasSingleton()) setFuturePossibleStructure(graph, m_currentKnownStructure.singleton()); filterArrayModesByType(); filterValueByType(); return normalizeClarity(); }
FiltrationResult AbstractValue::filter(const AbstractValue& other) { m_type &= other.m_type; m_structure.filter(other.m_structure); m_arrayModes &= other.m_arrayModes; m_structure.filter(m_type); filterArrayModesByType(); filterValueByType(); if (normalizeClarity() == Contradiction) return Contradiction; if (m_value == other.m_value) return FiltrationOK; // Neither of us are BOTTOM, so an empty value means TOP. if (!m_value) { // We previously didn't prove a value but now we have done so. m_value = other.m_value; return FiltrationOK; } if (!other.m_value) { // We had proved a value but the other guy hadn't, so keep our proof. return FiltrationOK; } // We both proved there to be a specific value but they are different. clear(); return Contradiction; }
FiltrationResult AbstractValue::filter(SpeculatedType type) { if ((m_type & type) == m_type) return FiltrationOK; // Fast path for the case that we don't even have a cell. if (!(m_type & SpecCell)) { m_type &= type; FiltrationResult result; if (m_type == SpecNone) { clear(); result = Contradiction; } else result = FiltrationOK; checkConsistency(); return result; } m_type &= type; // It's possible that prior to this filter() call we had, say, (Final, TOP), and // the passed type is Array. At this point we'll have (None, TOP). The best way // to ensure that the structure filtering does the right thing is to filter on // the new type (None) rather than the one passed (Array). m_structure.filter(type); filterArrayModesByType(); filterValueByType(); return normalizeClarity(); }
FiltrationResult AbstractValue::changeStructure(Graph& graph, const StructureSet& other) { m_type &= other.speculationFromStructures(); m_arrayModes = other.arrayModesFromStructures(); m_structure = other; filterValueByType(); return normalizeClarity(graph); }
FiltrationResult AbstractValue::filter(SpeculatedType type) { if ((m_type & type) == m_type) return FiltrationOK; m_type &= type; // It's possible that prior to this filter() call we had, say, (Final, TOP), and // the passed type is Array. At this point we'll have (None, TOP). The best way // to ensure that the structure filtering does the right thing is to filter on // the new type (None) rather than the one passed (Array). m_currentKnownStructure.filter(m_type); m_futurePossibleStructure.filter(m_type); filterArrayModesByType(); filterValueByType(); return normalizeClarity(); }