Method handleExternalCall

lib/rootdefanalysis/RDAnalyzer.cpp:601–736

}

std::set<RDNode> RDAnalyzer::handleExternalCall(RDNode &Node, CallBase &CB) {
  // 1. Checks whether a given RDNode is register or memory
  std::set<RDNode> Result;
  if (Node.isMemory()) {
    if (isMemoryIntrinsic(CB))
      return handleMemoryIntrinsicCall(Node, CB);

    // In memory case (ex: ... = external call(..., target, ...))
    // If trace target is a parameter of external call and the parameter
    // is known as the one whose direction is output, then stop tracing.
    // If not, keep tracing.

    // 1-1-1. Collect parameters whose direction is output.
    auto OutParamIndices = getOutParamIndices(CB);

    if (isTargetMethodInvocation(Node, CB)) {
      auto NonOutParamIndices = getNonOutParamIndices(CB);

      std::set<RDNode> NextNodes = {Node};
      for (auto NonOutParamIndex : NonOutParamIndices) {
        RDNode NextNode(NonOutParamIndex, CB, &Node);
        NextNode.setFirstUse(CB, NonOutParamIndex);
        NextNodes.insert(NextNode);
      }
      return NextNodes;
    }

    // 1-1-2. Collect tracing target is in out parameters.
    const auto &Target = Node.getTarget();
    bool SetFirstUse = false;
    std::vector<size_t> MatchedParamIndices;
    for (size_t S = 0, E = CB.getNumArgOperands(); S < E; ++S) {
      auto *Arg = CB.getArgOperand(S);
      assert(Arg && "Unexpected Program State");

      if (isPropagated(Target, *Arg) == PROPTYPE_NONE)
        continue;

      if (Target == *RDTarget::create(*Arg)) {
        if (SetFirstUse)
          Node.addFirstUse(CB, S);
        else {
          SetFirstUse = true;
          Node.setFirstUse(CB, S);
        }
      }

      if (OutParamIndices.find(S) == OutParamIndices.end())
        continue;

      MatchedParamIndices.push_back(S);
    }

    // 1-1-3. If tracing target is not an output parameter, go next.
    if (MatchedParamIndices.empty()) {
      return {Node};
    }