CommandLine.hpp

Go to the documentation of this file.

/*
 * Copyright 2022 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_TOOLING_COMMANDLINE_HPP
#define JLM_TOOLING_COMMANDLINE_HPP
 
#include <jlm/llvm/opt/RvsdgTreePrinter.hpp>
#include <jlm/util/BijectiveMap.hpp>
#include <jlm/util/file.hpp>
#include <jlm/util/Statistics.hpp>
 
#include <vector>
 
namespace jlm::tooling
{
 
class CommandLineOptions
{
public:
  virtual ~CommandLineOptions();
 
  CommandLineOptions() = default;
 
  virtual void
  Reset() noexcept = 0;
};
 
class optimization;
 
class JlmOptCommandLineOptions final : public CommandLineOptions
{
public:
  enum class InputFormat
  {
    Llvm,
    Mlir,
  };
 
  enum class OutputFormat
  {
    FirstEnumValue, // must always be the first enum value, used for iteration
 
    Ascii,
    Dot,
    Json,
    JsonTree,
    Llvm,
    Mlir,
    Tree,
 
    LastEnumValue // must always be the last enum value, used for iteration
  };
 
  enum class OptimizationId
  {
    FirstEnumValue, // must always be the first enum value, used for iteration
 
    AAAndersenAgnostic,
    AAAndersenRegionAware,
    AggregateAllocaSplitting,
    CommonNodeElimination,
    DeadNodeElimination,
    FunctionInlining,
    IfConversion,
    IOBarrierElimination,
    InvariantValueRedirection,
    LoadChainSeparation,
    LoopStrengthReduction,
    LoopUnrolling,
    LoopUnswitching,
    NodeHoisting,
    NodePullIn,
 
    NodePushOut,
 
    NodeReduction,
    PredicateCorrelation,
    RvsdgTreePrinter,
    ScalarEvolution,
    StoreValueForwarding,
 
    LastEnumValue // must always be the last enum value, used for iteration
  };
 
  JlmOptCommandLineOptions(
      util::FilePath inputFile,
      InputFormat inputFormat,
      util::FilePath outputFile,
      OutputFormat outputFormat,
      util::StatisticsCollectorSettings statisticsCollectorSettings,
      llvm::RvsdgTreePrinter::Configuration rvsdgTreePrinterConfiguration,
      std::vector<OptimizationId> optimizations,
      const bool dumpRvsdgGraphs)
      : InputFile_(std::move(inputFile)),
        InputFormat_(inputFormat),
        OutputFile_(std::move(outputFile)),
        OutputFormat_(outputFormat),
        StatisticsCollectorSettings_(std::move(statisticsCollectorSettings)),
        OptimizationIds_(std::move(optimizations)),
        RvsdgTreePrinterConfiguration_(std::move(rvsdgTreePrinterConfiguration)),
        dumpRvsdgGraphs_(dumpRvsdgGraphs)
  {}
 
  void
  Reset() noexcept override;
 
  [[nodiscard]] const util::FilePath &
  GetInputFile() const noexcept
  {
    return InputFile_;
  }
 
  [[nodiscard]] InputFormat
  GetInputFormat() const noexcept
  {
    return InputFormat_;
  }
 
  [[nodiscard]] const util::FilePath &
  GetOutputFile() const noexcept
  {
    return OutputFile_;
  }
 
  [[nodiscard]] OutputFormat
  GetOutputFormat() const noexcept
  {
    return OutputFormat_;
  }
 
  [[nodiscard]] const util::StatisticsCollectorSettings &
  GetStatisticsCollectorSettings() const noexcept
  {
    return StatisticsCollectorSettings_;
  }
 
  [[nodiscard]] const std::vector<OptimizationId> &
  GetOptimizationIds() const noexcept
  {
    return OptimizationIds_;
  }
 
  [[nodiscard]] const llvm::RvsdgTreePrinter::Configuration &
  GetRvsdgTreePrinterConfiguration() const noexcept
  {
    return RvsdgTreePrinterConfiguration_;
  }
 
  [[nodiscard]] bool
  dumpRvsdgGraphs() const noexcept
  {
    return dumpRvsdgGraphs_;
  }
 
  static OptimizationId
  FromCommandLineArgumentToOptimizationId(std::string_view commandLineArgument);
 
  static util::Statistics::Id
  FromCommandLineArgumentToStatisticsId(std::string_view commandLineArgument);
 
  static std::string_view
  ToCommandLineArgument(OptimizationId optimizationId);
 
  static std::string_view
  ToCommandLineArgument(util::Statistics::Id statisticsId);
 
  static std::string_view
  ToCommandLineArgument(InputFormat inputFormat);
 
  static std::string_view
  ToCommandLineArgument(OutputFormat outputFormat);
 
  static std::unique_ptr<JlmOptCommandLineOptions>
  Create(
      util::FilePath inputFile,
      InputFormat inputFormat,
      util::FilePath outputFile,
      OutputFormat outputFormat,
      util::StatisticsCollectorSettings statisticsCollectorSettings,
      llvm::RvsdgTreePrinter::Configuration rvsdgTreePrinterConfiguration,
      std::vector<OptimizationId> optimizations,
      bool dumpRvsdgGraphs)
  {
    return std::make_unique<JlmOptCommandLineOptions>(
        std::move(inputFile),
        inputFormat,
        std::move(outputFile),
        outputFormat,
        std::move(statisticsCollectorSettings),
        std::move(rvsdgTreePrinterConfiguration),
        std::move(optimizations),
        dumpRvsdgGraphs);
  }
 
private:
  util::FilePath InputFile_;
  InputFormat InputFormat_;
  util::FilePath OutputFile_;
  OutputFormat OutputFormat_;
  util::StatisticsCollectorSettings StatisticsCollectorSettings_;
  std::vector<OptimizationId> OptimizationIds_;
  llvm::RvsdgTreePrinter::Configuration RvsdgTreePrinterConfiguration_;
  bool dumpRvsdgGraphs_;
 
  static const util::BijectiveMap<util::Statistics::Id, std::string_view> &
  GetStatisticsIdCommandLineArguments();
 
  static const std::unordered_map<OutputFormat, std::string_view> &
  GetOutputFormatCommandLineArguments();
 
  static const util::BijectiveMap<OptimizationId, std::string_view> &
  GetOptimizationIdCommandLineMap();
};
 
class JlcCommandLineOptions final : public CommandLineOptions
{
public:
  class Compilation;
 
  enum class OptimizationLevel
  {
    O0,
    O1,
    O2,
    O3,
  };
 
  enum class LanguageStandard
  {
    None,
    Gnu89,
    Gnu99,
    C89,
    C99,
    C11,
    Cpp98,
    Cpp03,
    Cpp11,
    Cpp14,
  };
 
  JlcCommandLineOptions()
      : OnlyPrintCommands_(false),
        GenerateDebugInformation_(false),
        Verbose_(false),
        Rdynamic_(false),
        Suppress_(false),
        UsePthreads_(false),
        Md_(false),
        OptimizationLevel_(OptimizationLevel::O0),
        LanguageStandard_(LanguageStandard::None),
        OutputFile_("a.out")
  {}
 
  static std::string_view
  ToString(const OptimizationLevel & optimizationLevel);
 
  static std::string_view
  ToString(const LanguageStandard & languageStandard);
 
  void
  Reset() noexcept override;
 
  bool OnlyPrintCommands_;
  bool GenerateDebugInformation_;
  bool Verbose_;
  bool Rdynamic_;
  bool Suppress_;
  bool UsePthreads_;
 
  bool Md_;
 
  OptimizationLevel OptimizationLevel_;
  LanguageStandard LanguageStandard_;
 
  util::FilePath OutputFile_;
  std::vector<std::string> Libraries_;
  std::vector<std::string> MacroDefinitions_;
  std::vector<std::string> LibraryPaths_;
  std::vector<std::string> Warnings_;
  std::vector<std::string> IncludePaths_;
  std::vector<std::string> Flags_;
  std::vector<JlmOptCommandLineOptions::OptimizationId> JlmOptOptimizations_;
  util::HashSet<util::Statistics::Id> JlmOptPassStatistics_;
 
  std::vector<Compilation> Compilations_;
};
 
class JlcCommandLineOptions::Compilation
{
public:
  Compilation(
      util::FilePath inputFile,
      util::FilePath dependencyFile,
      util::FilePath outputFile,
      std::string mT,
      bool requiresParsing,
      bool requiresOptimization,
      bool requiresAssembly,
      bool requiresLinking)
      : RequiresLinking_(requiresLinking),
        RequiresParsing_(requiresParsing),
        RequiresOptimization_(requiresOptimization),
        RequiresAssembly_(requiresAssembly),
        InputFile_(std::move(inputFile)),
        OutputFile_(std::move(outputFile)),
        DependencyFile_(std::move(dependencyFile)),
        Mt_(std::move(mT))
  {}
 
  [[nodiscard]] const util::FilePath &
  InputFile() const noexcept
  {
    return InputFile_;
  }
 
  [[nodiscard]] const util::FilePath &
  DependencyFile() const noexcept
  {
    return DependencyFile_;
  }
 
  [[nodiscard]] const util::FilePath &
  OutputFile() const noexcept
  {
    return OutputFile_;
  }
 
  [[nodiscard]] const std::string &
  Mt() const noexcept
  {
    return Mt_;
  }
 
  void
  SetOutputFile(const util::FilePath & outputFile)
  {
    OutputFile_ = outputFile;
  }
 
  [[nodiscard]] bool
  RequiresParsing() const noexcept
  {
    return RequiresParsing_;
  }
 
  [[nodiscard]] bool
  RequiresOptimization() const noexcept
  {
    return RequiresOptimization_;
  }
 
  [[nodiscard]] bool
  RequiresAssembly() const noexcept
  {
    return RequiresAssembly_;
  }
 
  [[nodiscard]] bool
  RequiresLinking() const noexcept
  {
    return RequiresLinking_;
  }
 
private:
  bool RequiresLinking_;
  bool RequiresParsing_;
  bool RequiresOptimization_;
  bool RequiresAssembly_;
  util::FilePath InputFile_;
  util::FilePath OutputFile_;
  util::FilePath DependencyFile_;
  const std::string Mt_;
};
 
class JlmHlsCommandLineOptions final : public CommandLineOptions
{
public:
  enum class OutputFormat
  {
    Firrtl,
    Dot
  };
 
  JlmHlsCommandLineOptions()
      : InputFile_(""),
        OutputFiles_(""),
        OutputFormat_(OutputFormat::Firrtl),
        ExtractHlsFunction_(false),
        MemoryLatency_(10),
        dumpRvsdgGraphs_(false)
  {
    JLM_ASSERT(MemoryLatency_ > 0);
  }
 
  void
  Reset() noexcept override;
 
  util::FilePath InputFile_;
  util::FilePath OutputFiles_;
  OutputFormat OutputFormat_;
  std::string HlsFunction_;
  bool ExtractHlsFunction_;
  size_t MemoryLatency_;
  bool dumpRvsdgGraphs_;
};
 
class JhlsCommandLineOptions final : public CommandLineOptions
{
public:
  class Compilation;
 
  enum class OptimizationLevel
  {
    O0,
    O1,
    O2,
    O3
  };
 
  enum class LanguageStandard
  {
    None,
    Gnu89,
    Gnu99,
    C89,
    C99,
    C11,
    Cpp98,
    Cpp03,
    Cpp11,
    Cpp14
  };
 
  JhlsCommandLineOptions()
      : OnlyPrintCommands_(false),
        GenerateDebugInformation_(false),
        Verbose_(false),
        Rdynamic_(false),
        Suppress_(false),
        UsePthreads_(false),
        GenerateFirrtl_(false),
        Hls_(false),
        Md_(false),
        OptimizationLevel_(OptimizationLevel::O0),
        LanguageStandard_(LanguageStandard::None),
        OutputFile_("a.out")
  {}
 
  void
  Reset() noexcept override;
 
  bool OnlyPrintCommands_;
  bool GenerateDebugInformation_;
  bool Verbose_;
  bool Rdynamic_;
  bool Suppress_;
  bool UsePthreads_;
  bool GenerateFirrtl_;
  bool Hls_;
 
  bool Md_;
 
  OptimizationLevel OptimizationLevel_;
  LanguageStandard LanguageStandard_;
  util::FilePath OutputFile_;
  std::vector<std::string> Libraries_;
  std::vector<std::string> MacroDefinitions_;
  std::vector<std::string> LibraryPaths_;
  std::vector<std::string> Warnings_;
  std::vector<std::string> IncludePaths_;
  std::vector<std::string> Flags_;
  std::vector<std::string> JlmHls_;
 
  std::vector<Compilation> Compilations_;
  std::string HlsFunctionRegex_;
};
 
class JhlsCommandLineOptions::Compilation
{
public:
  Compilation(
      util::FilePath inputFile,
      util::FilePath dependencyFile,
      util::FilePath outputFile,
      std::string mT,
      bool parse,
      bool optimize,
      bool assemble,
      bool link)
      : RequiresLinking_(link),
        RequiresParsing_(parse),
        RequiresOptimization_(optimize),
        RequiresAssembly_(assemble),
        InputFile_(std::move(inputFile)),
        OutputFile_(std::move(outputFile)),
        DependencyFile_(std::move(dependencyFile)),
        Mt_(std::move(mT))
  {}
 
  [[nodiscard]] const util::FilePath &
  InputFile() const noexcept
  {
    return InputFile_;
  }
 
  [[nodiscard]] const util::FilePath &
  DependencyFile() const noexcept
  {
    return DependencyFile_;
  }
 
  [[nodiscard]] const util::FilePath &
  OutputFile() const noexcept
  {
    return OutputFile_;
  }
 
  [[nodiscard]] const std::string &
  Mt() const noexcept
  {
    return Mt_;
  }
 
  void
  SetOutputFile(const util::FilePath & outputFile)
  {
    OutputFile_ = outputFile;
  }
 
  [[nodiscard]] bool
  RequiresParsing() const noexcept
  {
    return RequiresParsing_;
  }
 
  [[nodiscard]] bool
  RequiresOptimization() const noexcept
  {
    return RequiresOptimization_;
  }
 
  [[nodiscard]] bool
  RequiresAssembly() const noexcept
  {
    return RequiresAssembly_;
  }
 
  [[nodiscard]] bool
  RequiresLinking() const noexcept
  {
    return RequiresLinking_;
  }
 
private:
  bool RequiresLinking_;
  bool RequiresParsing_;
  bool RequiresOptimization_;
  bool RequiresAssembly_;
  util::FilePath InputFile_;
  util::FilePath OutputFile_;
  util::FilePath DependencyFile_;
  const std::string Mt_;
};
 
class CommandLineParser
{
public:
  class Exception : public util::Error
  {
  public:
    ~Exception() noexcept override;
 
    explicit Exception(const std::string & message)
        : Error(message)
    {}
  };
 
  virtual ~CommandLineParser() noexcept;
 
  CommandLineParser() = default;
 
  virtual const CommandLineOptions &
  ParseCommandLineArguments(int argc, const char * const * argv) = 0;
};
 
class JlcCommandLineParser final : public CommandLineParser
{
public:
  ~JlcCommandLineParser() noexcept override;
 
  const JlcCommandLineOptions &
  ParseCommandLineArguments(int argc, const char * const * argv) override;
 
private:
  static bool
  IsObjectFile(const util::FilePath & file)
  {
    return file.suffix() == "o";
  }
 
  static util::FilePath
  ToObjectFile(const util::FilePath & file)
  {
    return file.Dirname().Join(file.base() + ".o");
  }
 
  static util::FilePath
  ToDependencyFile(const util::FilePath & file)
  {
    return file.Dirname().Join(file.base() + ".d");
  }
 
  JlcCommandLineOptions CommandLineOptions_;
};
 
class JlmOptCommandLineParser final : public CommandLineParser
{
public:
  ~JlmOptCommandLineParser() noexcept override;
 
  const JlmOptCommandLineOptions &
  ParseCommandLineArguments(int argc, const char * const * argv) override;
 
  static const JlmOptCommandLineOptions &
  Parse(int argc, const char * const * argv);
 
private:
  std::unique_ptr<JlmOptCommandLineOptions> CommandLineOptions_;
};
 
class JlmHlsCommandLineParser final : public CommandLineParser
{
public:
  ~JlmHlsCommandLineParser() noexcept override;
 
  const JlmHlsCommandLineOptions &
  ParseCommandLineArguments(int argc, const char * const * argv) override;
 
  static const JlmHlsCommandLineOptions &
  Parse(int argc, const char * const * argv);
 
private:
  JlmHlsCommandLineOptions CommandLineOptions_;
};
 
class JhlsCommandLineParser final : public CommandLineParser
{
public:
  ~JhlsCommandLineParser() noexcept override;
 
  const JhlsCommandLineOptions &
  ParseCommandLineArguments(int argc, const char * const * argv) override;
 
  static const JhlsCommandLineOptions &
  Parse(int argc, const char * const * arv);
 
private:
  static bool
  IsObjectFile(const util::FilePath & file);
 
  static util::FilePath
  CreateObjectFileFromFile(const util::FilePath & f);
 
  static util::FilePath
  CreateDependencyFileFromFile(const util::FilePath & f);
 
  JhlsCommandLineOptions CommandLineOptions_;
};
 
}
 
#endif // JLM_TOOLING_COMMANDLINE_HPP