static void setLiveValues(HashMap<Node*, AbstractValue>& values, HashSet<Node*>& live)
{
values.clear();
HashSet<Node*>::iterator iter = live.begin();
HashSet<Node*>::iterator end = live.end();
for (; iter != end; ++iter)
values.add(*iter, AbstractValue());
}
void AtTailAbstractState::createValueForNode(Node* node)
{
m_block->ssa->valuesAtTail.add(node, AbstractValue());
}
Value *DataflowAnalyzer::computeValue(const Term *term, const ReachingDefinitions &definitions) {
switch (term->kind()) {
case Term::INT_CONST: {
auto constant = term->asConstant();
Value *value = dataflow().getValue(constant);
value->setAbstractValue(constant->value());
value->makeNotStackOffset();
value->makeNotProduct();
value->makeNotReturnAddress();
return value;
}
case Term::INTRINSIC: {
auto intrinsic = term->asIntrinsic();
Value *value = dataflow().getValue(intrinsic);
switch (intrinsic->intrinsicKind()) {
case Intrinsic::UNKNOWN: /* FALLTHROUGH */
case Intrinsic::UNDEFINED: {
value->setAbstractValue(AbstractValue(term->size(), -1, -1));
value->makeNotStackOffset();
value->makeNotProduct();
value->makeNotReturnAddress();
break;
}
case Intrinsic::ZERO_STACK_OFFSET: {
value->setAbstractValue(AbstractValue(term->size(), -1, -1));
value->makeStackOffset(0);
value->makeNotProduct();
value->makeNotReturnAddress();
break;
}
case Intrinsic::RETURN_ADDRESS: {
value->setAbstractValue(AbstractValue(term->size(), -1, -1));
value->makeNotStackOffset();
value->makeNotProduct();
value->makeReturnAddress();
break;
}
default: {
log_.warning(tr("%1: Unknown kind of intrinsic: %2.").arg(Q_FUNC_INFO).arg(intrinsic->intrinsicKind()));
break;
}
}
return value;
}
case Term::MEMORY_LOCATION_ACCESS: /* FALLTHROUGH */
case Term::DEREFERENCE: {
const auto &memoryLocation = computeMemoryLocation(term, definitions);
const auto &reachingDefinitions = computeReachingDefinitions(term, memoryLocation, definitions);
return computeValue(term, memoryLocation, reachingDefinitions);
}
case Term::UNARY_OPERATOR:
return computeValue(term->asUnaryOperator(), definitions);
case Term::BINARY_OPERATOR:
return computeValue(term->asBinaryOperator(), definitions);
case Term::CHOICE: {
auto choice = term->asChoice();
auto value = dataflow().getValue(choice);
auto preferredValue = computeValue(choice->preferredTerm(), definitions);
auto defaultValue = computeValue(choice->defaultTerm(), definitions);
if (!dataflow().getDefinitions(choice->preferredTerm()).empty()) {
*value = *preferredValue;
} else {
*value = *defaultValue;
}
return value;
}
default: {
log_.warning(tr("%1: Unknown term kind: %2.").arg(Q_FUNC_INFO).arg(term->kind()));
return dataflow().getValue(term);
}
}
}
