Method handleMemoryCall

lib/rootdefanalysis/RDAnalyzer.cpp:488–599

}

std::set<RDNode> RDAnalyzer::handleMemoryCall(RDNode &Node, CallBase &CB) {
  auto *F = CB.getCalledFunction();
  if (!F)
    return {Node};

  if (F->isDeclaration()) {
    return handleExternalCall(Node, CB);
  }

  auto LeafMems = Space.nextInCallee(*F, true);
  if (LeafMems.size() == 0)
    return {Node};

  std::set<llvm::Value *> Cands;
  const auto &Target = Node.getTarget();

  if (Target.isGlobalVariable())
    Cands.insert(&Target.getIR());

  // CallBase Argument size always bigger than Function parameter size
  // because variable argument functions aceept additional arguments.
  for (unsigned S = 0, E = F->arg_size(); S < E; ++S) {
    auto *Arg = CB.getArgOperand(S);
    assert(Arg && "Unexpected Program State");

    auto *ArgType = Arg->getType();
    assert(ArgType && "Unexpected Program State");

    if (!ArgType->isPointerTy() || isPropagated(Target, *Arg) == PROPTYPE_NONE)
      continue;

    Cands.insert(F->getArg(S));
  }

  if (Cands.size() == 0)
    return {Node};

  bool NullFound = false;
  std::set<RDNode> Continues;
  std::set<RDNode> Result;

  for (auto LeafMem : LeafMems) {
    if (!LeafMem) {
      NullFound = true;
      continue;
    }

    std::set<RDNode> Founds;
    for (auto Cand : Cands) {
      RDNode NewNode(*Cand, *LeafMem, &Node);
      for (auto &Found : traverseFunction(NewNode, *F, false, true)) {
        if (&Found.getTarget().getIR() == Cand) {
          NullFound = true;
          continue;
        }
        Founds.insert(Found);
      }
    }