Method trace

lib/rootdefanalysis/RDAnalyzer.cpp:251–323

}

std::set<RDNode> RDAnalyzer::trace(RDNode &Node) {
  if (Node.isStopTracing())
    return {Node};

  if (Cache.has(Node)) {
    auto CachedNodes = Cache.get(Node);
    for (const auto &CachedNode : CachedNodes) {
      const_cast<RDNode *>(&CachedNode)->copyVisit(Node);
      if (CachedNode.getFirstUses().size() == 0) {
        const_cast<RDNode *>(&CachedNode)->setFirstUses(Node.getFirstUses());
      }
    }

    return CachedNodes;
  }

  if (Node.isRootDefinition()) {
    auto *CB = dyn_cast_or_null<CallBase>(&Node.getLocation());
    auto Idx = Node.getIdx();
    if (CB && Idx >= 0)
      Node.setFirstUse(*CB, Idx);
    return {Node};
  }

  auto &Location = Node.getLocation();
  if (Node.isVisit(Node.getTarget(), Location)) {
    return {};
  }

  if (Timeout != 0 && static_cast<unsigned>(time(NULL) - Start) > Timeout) {
    Node.timeout();
    return {Node};
  }

  RDNode NewNode = Node;
  NewNode.clearFirstUses();
  NewNode.visit(Node.getTarget(), Location);

  std::set<RDNode> Result;
  for (const auto &NextNode : next(NewNode))
    mergeRDNodes(Result, pass(*const_cast<RDNode *>(&NextNode)));

  // If there is timeout result, entire result is not cached.
  for (auto &Node : Result)
    if (Node.isTimeout())
      return Result;

  if (Result.size() > 0) {
    // Build cache.
    Cache.cache(NewNode, Result);

    // Prepare result. Use first use if found node has not first use.
    // This logic should be done after build cache, because built cache
    // at this point can not use first uses that were found previously.
    for (auto &FoundNode : Result) {
      auto &FNFUs = FoundNode.getFirstUses();

      if ((FNFUs.size() > 0) && (FNFUs.find(RDArgIndex()) == FNFUs.end()))