Method updateDefault

lib/propanalysis/ArrayAnalyzer.cpp:475–519

}

void ArrayAnalyzer::updateDefault(const llvm::Module &M) {
  if (!Report)
    return;

  const std::map<Intrinsic::ID, std::map<unsigned, int>> DefaultIntrinsicMap = {
      {{Intrinsic::memcpy, {{0, 2}, {1, 2}}},
       {Intrinsic::memmove, {{0, 2}, {1, 2}}},
       {Intrinsic::memset, {{0, 2}, {1, 2}}},
       {Intrinsic::memcpy_element_unordered_atomic, {{0, 2}, {1, 2}}},
       {Intrinsic::memmove_element_unordered_atomic, {{0, 2}, {1, 2}}},
       {Intrinsic::memset_element_unordered_atomic, {{0, 2}, {1, 2}}}}};
  const std::map<std::string, std::map<unsigned, int>> DefaultNameMap = {
      {{"memcpy", {{0, 2}, {1, 2}}},
       {"memmove", {{0, 2}, {1, 2}}},
       {"memset", {{0, 2}, {1, 2}}},
       {"memcpy_element_unordered_atomic", {{0, 2}, {1, 2}}},
       {"memmove_element_unordered_atomic", {{0, 2}, {1, 2}}},
       {"memset_element_unordered_atomic", {{0, 2}, {1, 2}}}}};

  for (const auto &F : M) {
    if (!F.isDeclaration())
      continue;

    auto IterIntrinsic = DefaultIntrinsicMap.find(F.getIntrinsicID());
    if (IterIntrinsic != DefaultIntrinsicMap.end()) {
      updateDefault(F, IterIntrinsic->second);
      continue;
    }

    auto IterName = DefaultNameMap.find(F.getName().str());
    if (IterName != DefaultNameMap.end())
      updateDefault(F, IterName->second);
  }

  for (auto Iter : ArgFlowMap) {
    auto &AF = Iter.second;
    if (!AF)
      continue;

    if (AF->getState() != AnalysisState_Pre_Analyzed)
      continue;

    Report->add(*AF);
  }
}

void ArrayAnalyzer::updateDefault(const llvm::Function &F,
                                  const std::map<unsigned, int> &Values) {