Class ArgPropAnalysisReport

include/ftg/propanalysis/ArgPropAnalysisReport.hpp:12–124

namespace ftg {

template <typename T> class ArgPropAnalysisReport : public AnalyzerReport {

public:
  std::tuple<std::string, unsigned, std::vector<int>>
  decomposeArgPropReportKey(std::string Key) const {
    auto Result =
        std::make_tuple<std::string, unsigned, std::vector<int>>("", 0, {});

    try {
      auto SIdx = Key.find("(");
      auto EIdx = Key.find(")");
      if (SIdx == std::string::npos || EIdx == std::string::npos)
        return Result;
      if (EIdx <= SIdx + 1)
        return Result;

      std::get<0>(Result) = Key.substr(0, SIdx);
      std::get<1>(Result) = std::stol(Key.substr(SIdx + 1, EIdx));

      SIdx = Key.rfind("[");
      EIdx = Key.rfind("]");
      if (SIdx == std::string::npos || EIdx == std::string::npos)
        return Result;

      std::vector<int> Indices;
      unsigned BaseOffset = SIdx + 1;
      for (unsigned S = SIdx + 1; S < EIdx; ++S) {
        if (Key[S] != ',')
          continue;
        Indices.emplace_back(std::stoi(Key.substr(BaseOffset, S)));
        BaseOffset = S + 1;
      }
      std::get<2>(Result) = Indices;
    } catch (std::exception &E) {
    }
    return Result;
  }

  void set(const llvm::Argument &Key, T Value, std::vector<int> Indices = {}) {
    auto RealKey = getAsKey(Key, Indices);
    Result.emplace(RealKey, Value);
  }

  void set(std::string FuncName, unsigned ArgIdx, T Value,
           std::vector<int> Indices = {}) {
    Result.emplace(getAsKey(FuncName, ArgIdx, Indices), Value);
  }

  void set(std::string Key, T Value) { Result.emplace(Key, Value); }

  void set(const std::map<std::string, T> &Map) { Result = Map; }

  bool has(const llvm::Argument &Key, std::vector<int> Indices = {}) const {
    auto RealKey = getAsKey(Key, Indices);
    return Result.find(RealKey) != Result.end();
  }

  bool has(std::string FuncName, unsigned ArgIdx,