FrontendOptions.h

//===- FrontendOptions.h ----------------------------------------*- 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_FRONTENDOPTIONS_H
#define FORTRAN_FRONTEND_FRONTENDOPTIONS_H
 
#include "flang/Common/Fortran-features.h"
#include "flang/Lower/EnvironmentDefault.h"
#include "flang/Parser/characters.h"
#include "flang/Parser/unparse.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/MemoryBuffer.h"
#include <cstdint>
#include <string>
 
namespace Fortran::frontend {
 
enum ActionKind {
  InputOutputTest,
 
  PrintPreprocessedInput,
 
  ParseSyntaxOnly,
 
  EmitFIR,
 
  EmitHLFIR,
 
  EmitLLVM,
 
  EmitLLVMBitcode,
 
  EmitObj,
 
  EmitAssembly,
 
  DebugUnparse,
 
  DebugUnparseNoSema,
 
  DebugUnparseWithSymbols,
 
  DebugUnparseWithModules,
 
  DebugDumpSymbols,
 
  DebugDumpParseTree,
 
  DebugDumpPFT,
 
  DebugDumpAll,
 
  DebugDumpParseTreeNoSema,
 
  DebugDumpProvenance,
 
  DebugDumpParsingLog,
 
  DebugMeasureParseTree,
 
  DebugPreFIRTree,
 
  GetDefinition,
 
  GetSymbolsSources,
 
  InitOnly,
 
  PluginAction
};
 
bool isFixedFormSuffix(llvm::StringRef suffix);
 
bool isFreeFormSuffix(llvm::StringRef suffix);
 
bool isToBePreprocessed(llvm::StringRef suffix);
 
bool isCUDAFortranSuffix(llvm::StringRef suffix);
 
enum class Language : uint8_t {
  Unknown,
 
  MLIR,
 
  LLVM_IR,
 
  Fortran,
};
 
// Source file layout
enum class FortranForm {
  Unknown,
 
  FixedForm,
 
  FreeForm
};
 
class InputKind {
private:
  Language lang;
 
public:
  enum Format { Source, ModuleMap, Precompiled };
 
  constexpr InputKind(Language l = Language::Unknown) : lang(l) {}
 
  Language getLanguage() const { return static_cast<Language>(lang); }
 
  bool isUnknown() const { return lang == Language::Unknown; }
};
 
class FrontendInputFile {
  std::string file;
 
  const llvm::MemoryBuffer *buffer = nullptr;
 
  InputKind kind;
 
  bool isFixedForm = false;
 
  unsigned mustBePreprocessed : 1;
 
  bool isCUDAFortran{false};
 
public:
  FrontendInputFile() = default;
  FrontendInputFile(llvm::StringRef file, InputKind inKind)
      : file(file.str()), kind(inKind) {
 
    // Based on the extension, decide whether this is a fixed or free form
    // file.
    auto pathDotIndex{file.rfind(".")};
    std::string pathSuffix{file.substr(pathDotIndex + 1)};
    isFixedForm = isFixedFormSuffix(pathSuffix);
    mustBePreprocessed = isToBePreprocessed(pathSuffix);
    isCUDAFortran = isCUDAFortranSuffix(pathSuffix);
  }
 
  FrontendInputFile(const llvm::MemoryBuffer *memBuf, InputKind inKind)
      : buffer(memBuf), kind(inKind) {}
 
  InputKind getKind() const { return kind; }
 
  bool isEmpty() const { return file.empty() && buffer == nullptr; }
  bool isFile() const { return (buffer == nullptr); }
  bool getIsFixedForm() const { return isFixedForm; }
  bool getMustBePreprocessed() const { return mustBePreprocessed; }
  bool getIsCUDAFortran() const { return isCUDAFortran; }
 
  llvm::StringRef getFile() const {
    assert(isFile());
    return file;
  }
 
  const llvm::MemoryBuffer *getBuffer() const {
    assert(buffer && "Requested buffer, but it is empty!");
    return buffer;
  }
};
 
struct FrontendOptions {
  FrontendOptions()
      : showHelp(false), showVersion(false), instrumentedParse(false),
        showColors(false), printSupportedCPUs(false),
        needProvenanceRangeToCharBlockMappings(false) {}
 
  unsigned showHelp : 1;
 
  unsigned showVersion : 1;
 
  unsigned instrumentedParse : 1;
 
  unsigned showColors : 1;
 
  unsigned printSupportedCPUs : 1;
 
  unsigned needProvenanceRangeToCharBlockMappings : 1;
 
  struct GetDefinitionVals {
    unsigned line;
    unsigned startColumn;
    unsigned endColumn;
  };
  GetDefinitionVals getDefVals;
 
  std::vector<FrontendInputFile> inputs;
 
  std::string outputFile;
 
  frontend::ActionKind programAction = ParseSyntaxOnly;
 
  // The form to process files in, if specified.
  FortranForm fortranForm = FortranForm::Unknown;
 
  // Default values for environment variables to be set by the runtime.
  std::vector<Fortran::lower::EnvironmentDefault> envDefaults;
 
  // The column after which characters are ignored in fixed form lines in the
  // source file.
  int fixedFormColumns = 72;
 
  InputKind dashX;
 
  // Language features
  common::LanguageFeatureControl features;
 
  // Source file encoding
  Fortran::parser::Encoding encoding{Fortran::parser::Encoding::UTF_8};
 
  std::vector<std::string> plugins;
 
  std::string actionName;
 
  std::vector<std::string> llvmArgs;
 
  std::vector<std::string> mlirArgs;
 
  // Return the appropriate input kind for a file extension. For example,
  static InputKind getInputKindForExtension(llvm::StringRef extension);
};
} // namespace Fortran::frontend
 
#endif // FORTRAN_FRONTEND_FRONTENDOPTIONS_H