CodeGenOptions.h

//===--- CodeGenOptions.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
//
//===----------------------------------------------------------------------===//
//
//  This file defines the CodeGenOptions interface, which holds the
//  configuration for LLVM's middle-end and back-end. It controls LLVM's code
//  generation into assembly or machine code.
//
//===----------------------------------------------------------------------===//
 
#ifndef FORTRAN_FRONTEND_CODEGENOPTIONS_H
#define FORTRAN_FRONTEND_CODEGENOPTIONS_H
 
#include "llvm/Frontend/Debug/Options.h"
#include "llvm/Frontend/Driver/CodeGenOptions.h"
#include "llvm/Support/CodeGen.h"
#include "llvm/Support/Regex.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/Transforms/Instrumentation/AddressSanitizerOptions.h"
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace Fortran::frontend {
 
class CodeGenOptionsBase {
 
public:
#define CODEGENOPT(Name, Bits, Default) unsigned Name : Bits;
#define ENUM_CODEGENOPT(Name, Type, Bits, Default)
#include "flang/Frontend/CodeGenOptions.def"
 
protected:
#define CODEGENOPT(Name, Bits, Default)
#define ENUM_CODEGENOPT(Name, Type, Bits, Default) unsigned Name : Bits;
#include "flang/Frontend/CodeGenOptions.def"
};
 
class CodeGenOptions : public CodeGenOptionsBase {
 
public:
  std::vector<std::string> LLVMPassPlugins;
 
  std::vector<std::string> OffloadObjects;
 
  std::vector<std::string> BuiltinBCLibs;
 
  std::optional<std::string> SaveTempsDir;
 
  std::optional<std::string> RecordCommandLine;
 
  std::string OptRecordFile;
 
  std::string OptRecordPasses;
 
  std::string OptRecordFormat;
 
  std::vector<std::string> DependentLibs;
 
  // The RemarkKind enum class and OptRemark struct are identical to what Clang
  // has
  // TODO: Share with clang instead of re-implementing here
  enum class RemarkKind {
    RK_Missing,     // Remark argument not present on the command line.
    RK_Enabled,     // Remark enabled via '-Rgroup', i.e. -Rpass, -Rpass-missed,
                    // -Rpass-analysis
    RK_Disabled,    // Remark disabled via '-Rno-group', i.e. -Rno-pass,
                    // -Rno-pass-missed, -Rno-pass-analysis.
    RK_WithPattern, // Remark pattern specified via '-Rgroup=regexp'.
  };
 
  llvm::CodeObjectVersionKind CodeObjectVersion =
      llvm::CodeObjectVersionKind::COV_5;
 
  struct OptRemark {
    RemarkKind Kind = RemarkKind::RK_Missing;
    std::string Pattern;
    std::shared_ptr<llvm::Regex> Regex;
 
    OptRemark() = default;
 
    bool hasValidPattern() const { return Regex != nullptr; }
 
    bool patternMatches(llvm::StringRef string) const {
      return hasValidPattern() && Regex->match(string);
    }
  };
 
  // The OptRemark fields provided here are identical to Clang.
 
  OptRemark OptimizationRemark;
 
  OptRemark OptimizationRemarkMissed;
 
  OptRemark OptimizationRemarkAnalysis;
 
  std::string CodeModel;
 
  uint64_t LargeDataThreshold;
 
  // Define accessors/mutators for code generation options of enumeration type.
#define CODEGENOPT(Name, Bits, Default)
#define ENUM_CODEGENOPT(Name, Type, Bits, Default)                             \
  Type get##Name() const { return static_cast<Type>(Name); }                   \
  void set##Name(Type Value) { Name = static_cast<unsigned>(Value); }
#include "flang/Frontend/CodeGenOptions.def"
 
  CodeGenOptions();
};
 
std::optional<llvm::CodeModel::Model> getCodeModel(llvm::StringRef string);
 
} // end namespace Fortran::frontend
 
#endif // FORTRAN_FRONTEND_CODEGENOPTIONS_H