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(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::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;
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();
}
