CompilerInstance.h

//===-- CompilerInstance.h - Flang Compiler Instance ------------*- 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_COMPILERINSTANCE_H
#define FORTRAN_FRONTEND_COMPILERINSTANCE_H
 
#include "flang/Frontend/CompilerInvocation.h"
#include "flang/Frontend/FrontendAction.h"
#include "flang/Frontend/ParserActions.h"
#include "flang/Frontend/PreprocessorOptions.h"
#include "flang/Semantics/runtime-type-info.h"
#include "flang/Semantics/semantics.h"
#include "flang/Support/StringOstream.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetMachine.h"
 
namespace Fortran::frontend {

class CompilerInstance {

  std::shared_ptr<CompilerInvocation> invocation;

  std::shared_ptr<Fortran::parser::AllSources> allSources;
 
  std::shared_ptr<Fortran::parser::AllCookedSources> allCookedSources;
 
  std::shared_ptr<Fortran::parser::Parsing> parsing;
 
  std::unique_ptr<Fortran::semantics::Semantics> semantics;
 
  std::unique_ptr<Fortran::semantics::RuntimeDerivedTypeTables> rtTyTables;
 
  std::unique_ptr<Fortran::semantics::SemanticsContext> semaContext;
 
  std::unique_ptr<llvm::TargetMachine> targetMachine;

  llvm::raw_ostream *semaOutputStream = &llvm::errs();

  std::unique_ptr<llvm::raw_ostream> ownedSemaOutputStream;

  llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics;

  struct OutputFile {
    std::string filename;
    OutputFile(std::string inputFilename)
        : filename(std::move(inputFilename)) {}
  };

  std::list<OutputFile> outputFiles;

  std::unique_ptr<llvm::raw_pwrite_stream> outputStream;

  mlir::DefaultTimingManager timingMgr;

  mlir::TimingScope timingScopeRoot;

  std::unique_ptr<Fortran::support::string_ostream> timingStreamMLIR;
  std::unique_ptr<Fortran::support::string_ostream> timingStreamLLVM;
  std::unique_ptr<Fortran::support::string_ostream> timingStreamCodeGen;
 
public:
  explicit CompilerInstance();
 
  ~CompilerInstance();

 
  CompilerInvocation &getInvocation() {
    assert(invocation && "Compiler instance has no invocation!");
    return *invocation;
  };

  void setInvocation(std::shared_ptr<CompilerInvocation> value);


  Fortran::parser::AllSources &getAllSources() const { return *allSources; }
 
  bool hasAllSources() const { return allSources != nullptr; }
 
  parser::AllCookedSources &getAllCookedSources() {
    assert(allCookedSources && "Compiler instance has no AllCookedSources!");
    return *allCookedSources;
  };


  Fortran::parser::Parsing &getParsing() const { return *parsing; }

 
  Fortran::semantics::SemanticsContext &createNewSemanticsContext() {
    semaContext =
        getInvocation().getSemanticsCtx(*allCookedSources, getTargetMachine());
    return *semaContext;
  }
 
  Fortran::semantics::SemanticsContext &getSemanticsContext() {
    return *semaContext;
  }
  const Fortran::semantics::SemanticsContext &getSemanticsContext() const {
    return *semaContext;
  }

  void setSemaOutputStream(llvm::raw_ostream &value);

  void setSemaOutputStream(std::unique_ptr<llvm::raw_ostream> value);

  llvm::raw_ostream &getSemaOutputStream() { return *semaOutputStream; }
 
  Fortran::semantics::Semantics &getSemantics() { return *semantics; }
  const Fortran::semantics::Semantics &getSemantics() const {
    return *semantics;
  }
 
  void setSemantics(std::unique_ptr<Fortran::semantics::Semantics> sema) {
    semantics = std::move(sema);
  }
 
  void setRtTyTables(
      std::unique_ptr<Fortran::semantics::RuntimeDerivedTypeTables> tables) {
    rtTyTables = std::move(tables);
  }
 
  Fortran::semantics::RuntimeDerivedTypeTables &getRtTyTables() {
    assert(rtTyTables && "Missing runtime derived type tables!");
    return *rtTyTables;
  }


  bool executeAction(FrontendAction &act);

 
  clang::DiagnosticOptions &getDiagnosticOpts() {
    return invocation->getDiagnosticOpts();
  }
  const clang::DiagnosticOptions &getDiagnosticOpts() const {
    return invocation->getDiagnosticOpts();
  }
 
  FrontendOptions &getFrontendOpts() { return invocation->getFrontendOpts(); }
  const FrontendOptions &getFrontendOpts() const {
    return invocation->getFrontendOpts();
  }
 
  PreprocessorOptions &preprocessorOpts() {
    return invocation->getPreprocessorOpts();
  }
  const PreprocessorOptions &preprocessorOpts() const {
    return invocation->getPreprocessorOpts();
  }

 
  bool hasDiagnostics() const { return diagnostics != nullptr; }

  clang::DiagnosticsEngine &getDiagnostics() const {
    assert(diagnostics && "Compiler instance has no diagnostics!");
    return *diagnostics;
  }
 
  clang::DiagnosticConsumer &getDiagnosticClient() const {
    assert(diagnostics && diagnostics->getClient() &&
           "Compiler instance has no diagnostic client!");
    return *diagnostics->getClient();
  }


  void clearOutputFiles(bool eraseFiles);

  std::unique_ptr<llvm::raw_pwrite_stream>
  createDefaultOutputFile(bool binary = true, llvm::StringRef baseInput = "",
                          llvm::StringRef extension = "");


  const llvm::TargetMachine &getTargetMachine() const {
    assert(targetMachine && "target machine was not set");
    return *targetMachine;
  }
  llvm::TargetMachine &getTargetMachine() {
    assert(targetMachine && "target machine was not set");
    return *targetMachine;
  }

  bool setUpTargetMachine();

  std::string getTargetFeatures();

  bool isTimingEnabled() const { return timingMgr.isEnabled(); }
 
  mlir::DefaultTimingManager &getTimingManager() { return timingMgr; }
  const mlir::DefaultTimingManager &getTimingManager() const {
    return timingMgr;
  }
 
  mlir::TimingScope &getTimingScopeRoot() { return timingScopeRoot; }
  const mlir::TimingScope &getTimingScopeRoot() const {
    return timingScopeRoot;
  }

  llvm::raw_ostream &getTimingStreamMLIR() {
    assert(timingStreamMLIR && "Timing stream for MLIR was not set");
    return *timingStreamMLIR;
  }

  llvm::raw_ostream &getTimingStreamLLVM() {
    assert(timingStreamLLVM && "Timing stream for LLVM was not set");
    return *timingStreamLLVM;
  }

  llvm::raw_ostream &getTimingStreamCodeGen() {
    assert(timingStreamCodeGen && "Timing stream for codegen was not set");
    return *timingStreamCodeGen;
  }

 
private:
  llvm::Expected<std::unique_ptr<llvm::raw_pwrite_stream>>
  createOutputFileImpl(llvm::StringRef outputPath, bool binary);
 
public:

  static clang::IntrusiveRefCntPtr<clang::DiagnosticsEngine>
  createDiagnostics(clang::DiagnosticOptions &opts,
                    clang::DiagnosticConsumer *client = nullptr,
                    bool shouldOwnClient = true);
  void createDiagnostics(clang::DiagnosticConsumer *client = nullptr,
                         bool shouldOwnClient = true);

  void setOutputStream(std::unique_ptr<llvm::raw_pwrite_stream> outStream) {
    outputStream = std::move(outStream);
  }
 
  bool isOutputStreamNull() { return (outputStream == nullptr); }
 
  // Allow the frontend compiler to write in the output stream.
  void writeOutputStream(const std::string &message) {
    *outputStream << message;
  }

  llvm::raw_pwrite_stream &getOutputStream() {
    assert(outputStream &&
           "Compiler instance has no user-specified output stream!");
    return *outputStream;
  }
};
 
} // end namespace Fortran::frontend
#endif // FORTRAN_FRONTEND_COMPILERINSTANCE_H