llvm/tools/llvm-remarkutil/RemarkUtilHelpers.cpp

//===- RemarkUtilHelpers.cpp ----------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Helpers for remark utilites
//
//===----------------------------------------------------------------------===//
#include "RemarkUtilHelpers.h"

namespace llvm {
namespace remarks {
/// \returns A MemoryBuffer for the input file on success, and an Error
/// otherwise.
Expected<std::unique_ptr<MemoryBuffer>>
getInputMemoryBuffer(StringRef InputFileName) {
  auto MaybeBuf = MemoryBuffer::getFileOrSTDIN(InputFileName);
  if (auto ErrorCode = MaybeBuf.getError())
    return createStringError(ErrorCode,
                             Twine("Cannot open file '" + InputFileName +
                                   "': " + ErrorCode.message()));
  return std::move(*MaybeBuf);
}

/// \returns A ToolOutputFile which can be used for outputting the results of
/// some tool mode.
/// \p OutputFileName is the desired destination.
/// \p Flags controls whether or not the file is opened for writing in text
/// mode, as a binary, etc. See sys::fs::OpenFlags for more detail.
Expected<std::unique_ptr<ToolOutputFile>>
getOutputFileWithFlags(StringRef OutputFileName, sys::fs::OpenFlags Flags) {
  if (OutputFileName == "")
    OutputFileName = "-";
  std::error_code ErrorCode;
  auto OF = std::make_unique<ToolOutputFile>(OutputFileName, ErrorCode, Flags);
  if (ErrorCode)
    return errorCodeToError(ErrorCode);
  return std::move(OF);
}

/// \returns A ToolOutputFile which can be used for writing remarks on success,
/// and an Error otherwise.
/// \p OutputFileName is the desired destination.
/// \p OutputFormat
Expected<std::unique_ptr<ToolOutputFile>>
getOutputFileForRemarks(StringRef OutputFileName, Format OutputFormat) {
  assert((OutputFormat == Format::YAML || OutputFormat == Format::Bitstream) &&
         "Expected one of YAML or Bitstream!");
  return getOutputFileWithFlags(OutputFileName, OutputFormat == Format::YAML
                                                    ? sys::fs::OF_TextWithCRLF
                                                    : sys::fs::OF_None);
}

Format getSerializerFormat(StringRef OutputFileName, Format SelectedFormat,
                           Format DefaultFormat) {
  if (SelectedFormat != Format::Auto)
    return SelectedFormat;
  SelectedFormat = DefaultFormat;
  if (OutputFileName.empty() || OutputFileName == "-" ||
      OutputFileName.ends_with_insensitive(".yaml") ||
      OutputFileName.ends_with_insensitive(".yml"))
    SelectedFormat = Format::YAML;
  if (OutputFileName.ends_with_insensitive(".bitstream"))
    SelectedFormat = Format::Bitstream;
  return SelectedFormat;
}

Expected<FilterMatcher>
FilterMatcher::createRE(const llvm::cl::opt<std::string> &Arg) {
  return createRE(Arg.ArgStr, Arg);
}

Expected<FilterMatcher>
FilterMatcher::createRE(StringRef Filter, const cl::list<std::string> &Arg) {
  return createRE(Arg.ArgStr, Filter);
}

Expected<FilterMatcher> FilterMatcher::createRE(StringRef Arg,
                                                StringRef Value) {
  FilterMatcher FM(Value, true);
  std::string Error;
  if (!FM.FilterRE.isValid(Error))
    return createStringError(make_error_code(std::errc::invalid_argument),
                             "invalid argument '--" + Arg + "=" + Value +
                                 "': " + Error);
  return std::move(FM);
}

Expected<std::optional<FilterMatcher>>
FilterMatcher::createExactOrRE(const llvm::cl::opt<std::string> &ExactArg,
                               const llvm::cl::opt<std::string> &REArg) {
  if (!ExactArg.empty() && !REArg.empty())
    return createStringError(make_error_code(std::errc::invalid_argument),
                             "conflicting arguments: --" + ExactArg.ArgStr +
                                 " and --" + REArg.ArgStr);

  if (!ExactArg.empty())
    return createExact(ExactArg);

  if (!REArg.empty())
    return createRE(REArg);

  return std::nullopt;
}

bool Filters::filterRemark(const Remark &Remark) {
  if (FunctionFilter && !FunctionFilter->match(Remark.FunctionName))
    return false;
  if (RemarkNameFilter && !RemarkNameFilter->match(Remark.RemarkName))
    return false;
  if (PassNameFilter && !PassNameFilter->match(Remark.PassName))
    return false;
  if (RemarkTypeFilter)
    return *RemarkTypeFilter == Remark.RemarkType;
  if (ArgFilter) {
    if (!any_of(Remark.Args,
                [this](Argument Arg) { return ArgFilter->match(Arg.Val); }))
      return false;
  }
  return true;
}

} // namespace remarks
} // namespace llvm