Method initializeRDAnalyzer

lib/inputanalysis/DefAnalyzer.cpp:40–93

}

void DefAnalyzer::initializeRDAnalyzer(
    const SourceCollection &SC, const DirectionAnalysisReport &DirectionReport,
    const FilePathAnalysisReport &FilePathReport) {
  RDExtension Extension;

  auto NewDirectionReport = std::make_shared<DirectionAnalysisReport>();
  assert(NewDirectionReport && "Unexpected Program State");

  for (auto Iter : DirectionReport.get()) {
    NewDirectionReport->set(Iter.first, Iter.second);
  }

  for (auto *Constructor : util::collectConstructors(SC.getASTUnits())) {
    if (!Constructor)
      continue;

    for (auto &MangledName : util::getMangledNames(*Constructor)) {
      auto *F = Loader->getSourceCollection().getLLVMModule().getFunction(
          MangledName);
      if (!F)
        continue;

      unsigned Idx = 0;
      if (F->hasStructRetAttr())
        Idx += 1;

      auto *A = F->getArg(Idx);
      if (!A)
        continue;

      NewDirectionReport->set(*A, Dir_Out);
    }
  }

  Extension.setDirectionReport(NewDirectionReport);

  for (const auto &Iter : FilePathReport.get()) {
    if (!Iter.second)
      continue;

    auto DecomposedKey = FilePathReport.decomposeArgPropReportKey(Iter.first);
    Extension.addTermination(std::get<0>(DecomposedKey),
                             std::get<1>(DecomposedKey));
  }

  for (const auto *Method :
       util::collectNonStaticClassMethods(SC.getASTUnits())) {
    assert(Method && "Unexpected Program State");
    for (auto &MangledName : util::getMangledNames(*Method))
      Extension.addNonStaticClassMethod(MangledName);
  }

  Analyzer = std::make_unique<RDAnalyzer>(30, &Extension);
}

std::map<Unittest *, std::vector<DefAnalyzer::FuncDef>>
DefAnalyzer::analyzeUTDefs() {