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