CompilerInvocation.h

//===- CompilerInvocation.h - Compiler Invocation Helper Data ---*- C -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
//
//===----------------------------------------------------------------------===//
 
#ifndef FORTRAN_FRONTEND_COMPILERINVOCATION_H
#define FORTRAN_FRONTEND_COMPILERINVOCATION_H
 
#include "flang/Common/LangOptions.h"
#include "flang/Frontend/CodeGenOptions.h"
#include "flang/Frontend/FrontendOptions.h"
#include "flang/Frontend/PreprocessorOptions.h"
#include "flang/Frontend/TargetOptions.h"
#include "flang/Lower/LoweringOptions.h"
#include "flang/Parser/parsing.h"
#include "flang/Semantics/semantics.h"
#include "mlir/Support/Timing.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/DiagnosticOptions.h"
#include "llvm/Option/ArgList.h"
#include <memory>
 
namespace llvm {
class TargetMachine;
}
 
namespace Fortran::frontend {
 
bool parseDiagnosticArgs(clang::DiagnosticOptions &opts,
                         llvm::opt::ArgList &args);
 
class CompilerInvocationBase {
public:
  llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> diagnosticOpts;
  std::shared_ptr<Fortran::frontend::PreprocessorOptions> preprocessorOpts;
 
  CompilerInvocationBase();
  CompilerInvocationBase(const CompilerInvocationBase &x);
  ~CompilerInvocationBase();
 
  clang::DiagnosticOptions &getDiagnosticOpts() {
    return *diagnosticOpts.get();
  }
  const clang::DiagnosticOptions &getDiagnosticOpts() const {
    return *diagnosticOpts.get();
  }
 
  PreprocessorOptions &getPreprocessorOpts() { return *preprocessorOpts; }
  const PreprocessorOptions &getPreprocessorOpts() const {
    return *preprocessorOpts;
  }
};
 
class CompilerInvocation : public CompilerInvocationBase {
  // TODO: Merge with or translate to parserOpts_. We shouldn't need two sets of
  // options.
  FrontendOptions frontendOpts;
 
  // TODO: Merge with or translate to frontendOpts. We shouldn't need two sets
  // of options.
  Fortran::parser::Options parserOpts;
 
  Fortran::lower::LoweringOptions loweringOpts;
 
  Fortran::frontend::TargetOptions targetOpts;
 
  Fortran::frontend::CodeGenOptions codeGenOpts;
 
  Fortran::common::LangOptions langOpts;
 
  // The original invocation of the compiler driver.
  // This string will be set as the return value from the COMPILER_OPTIONS
  // intrinsic of iso_fortran_env.
  std::string allCompilerInvocOpts;
 
  // TODO: Merge with or translate to frontendOpts. We shouldn't need two sets
  // of options.
  std::string moduleDir = ".";
 
  std::string moduleFileSuffix = ".mod";
 
  bool debugModuleDir = false;
  bool hermeticModuleFileOutput = false;
 
  bool warnAsErr = false;
 
  // Executable name
  const char *argv0;
 
  bool useAnalyzedObjectsForUnparse = true;
 
  // Fortran Dialect options
  Fortran::common::IntrinsicTypeDefaultKinds defaultKinds;
 
  // Fortran Warning options
  bool enableConformanceChecks = false;
  bool enableUsageChecks = false;
  bool disableWarnings = false;
 
  Fortran::parser::AnalyzedObjectsAsFortran asFortran{
      [](llvm::raw_ostream &o, const Fortran::evaluate::GenericExprWrapper &x) {
        if (x.v) {
          x.v->AsFortran(o);
        } else {
          o << "(bad expression)";
        }
      },
      [](llvm::raw_ostream &o,
         const Fortran::evaluate::GenericAssignmentWrapper &x) {
        if (x.v) {
          x.v->AsFortran(o);
        } else {
          o << "(bad assignment)";
        }
      },
      [](llvm::raw_ostream &o, const Fortran::evaluate::ProcedureRef &x) {
        x.AsFortran(o << "CALL ");
      },
  };
 
  bool enableTimers;
 
public:
  CompilerInvocation() = default;
 
  FrontendOptions &getFrontendOpts() { return frontendOpts; }
  const FrontendOptions &getFrontendOpts() const { return frontendOpts; }
 
  Fortran::parser::Options &getFortranOpts() { return parserOpts; }
  const Fortran::parser::Options &getFortranOpts() const { return parserOpts; }
 
  TargetOptions &getTargetOpts() { return targetOpts; }
  const TargetOptions &getTargetOpts() const { return targetOpts; }
 
  CodeGenOptions &getCodeGenOpts() { return codeGenOpts; }
  const CodeGenOptions &getCodeGenOpts() const { return codeGenOpts; }
 
  Fortran::common::LangOptions &getLangOpts() { return langOpts; }
  const Fortran::common::LangOptions &getLangOpts() const { return langOpts; }
 
  Fortran::lower::LoweringOptions &getLoweringOpts() { return loweringOpts; }
  const Fortran::lower::LoweringOptions &getLoweringOpts() const {
    return loweringOpts;
  }
 
  std::unique_ptr<Fortran::semantics::SemanticsContext>
  getSemanticsCtx(Fortran::parser::AllCookedSources &allCookedSources,
                  const llvm::TargetMachine &);
 
  std::string &getModuleDir() { return moduleDir; }
  const std::string &getModuleDir() const { return moduleDir; }
 
  std::string &getModuleFileSuffix() { return moduleFileSuffix; }
  const std::string &getModuleFileSuffix() const { return moduleFileSuffix; }
 
  bool &getDebugModuleDir() { return debugModuleDir; }
  const bool &getDebugModuleDir() const { return debugModuleDir; }
 
  bool &getHermeticModuleFileOutput() { return hermeticModuleFileOutput; }
  const bool &getHermeticModuleFileOutput() const {
    return hermeticModuleFileOutput;
  }
 
  bool &getWarnAsErr() { return warnAsErr; }
  const bool &getWarnAsErr() const { return warnAsErr; }
 
  bool &getUseAnalyzedObjectsForUnparse() {
    return useAnalyzedObjectsForUnparse;
  }
  const bool &getUseAnalyzedObjectsForUnparse() const {
    return useAnalyzedObjectsForUnparse;
  }
 
  bool &getEnableConformanceChecks() { return enableConformanceChecks; }
  const bool &getEnableConformanceChecks() const {
    return enableConformanceChecks;
  }
 
  const char *getArgv0() { return argv0; }
 
  bool &getEnableUsageChecks() { return enableUsageChecks; }
  const bool &getEnableUsageChecks() const { return enableUsageChecks; }
 
  bool &getDisableWarnings() { return disableWarnings; }
  const bool &getDisableWarnings() const { return disableWarnings; }
 
  Fortran::parser::AnalyzedObjectsAsFortran &getAsFortran() {
    return asFortran;
  }
  const Fortran::parser::AnalyzedObjectsAsFortran &getAsFortran() const {
    return asFortran;
  }
 
  Fortran::common::IntrinsicTypeDefaultKinds &getDefaultKinds() {
    return defaultKinds;
  }
  const Fortran::common::IntrinsicTypeDefaultKinds &getDefaultKinds() const {
    return defaultKinds;
  }
 
  bool getEnableTimers() const { return enableTimers; }
 
  static bool createFromArgs(CompilerInvocation &res,
                             llvm::ArrayRef<const char *> commandLineArgs,
                             clang::DiagnosticsEngine &diags,
                             const char *argv0 = nullptr);
 
  // Enables the std=f2018 conformance check
  void setEnableConformanceChecks() { enableConformanceChecks = true; }
 
  // Enables the usage checks
  void setEnableUsageChecks() { enableUsageChecks = true; }
 
  // Disables all Warnings
  void setDisableWarnings() { disableWarnings = true; }
 
  void setArgv0(const char *dir) { argv0 = dir; }
 
  void setModuleDir(std::string &dir) { moduleDir = dir; }
 
  void setModuleFileSuffix(const char *suffix) {
    moduleFileSuffix = std::string(suffix);
  }
 
  void setDebugModuleDir(bool flag) { debugModuleDir = flag; }
  void setHermeticModuleFileOutput(bool flag) {
    hermeticModuleFileOutput = flag;
  }
 
  void setWarnAsErr(bool flag) { warnAsErr = flag; }
 
  void setUseAnalyzedObjectsForUnparse(bool flag) {
    useAnalyzedObjectsForUnparse = flag;
  }
 
  // TODO: We should map frontendOpts_ to parserOpts_ instead. For that, we
  // need to extend frontendOpts_ first. Next, we need to add the corresponding
  // compiler driver options in libclangDriver.
  void setDefaultFortranOpts();
 
  void setDefaultPredefinitions();
 
  void collectMacroDefinitions();
 
  void setFortranOpts();
 
  void setSemanticsOpts(Fortran::parser::AllCookedSources &);
 
  void setLoweringOptions();
};
 
} // end namespace Fortran::frontend
#endif // FORTRAN_FRONTEND_COMPILERINVOCATION_H