CodeGen.h

Go to the documentation of this file.

//===-- llvm/Support/CodeGen.h - CodeGen Concepts ---------------*- 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 define some types which define code generation concepts. For
// example, relocation model.
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_SUPPORT_CODEGEN_H
#define LLVM_SUPPORT_CODEGEN_H
 
#include "llvm/ADT/StringRef.h"
#include <cstdint>
#include <optional>
 
namespace llvm {
 
  // Relocation model types.
  namespace Reloc {
    // Cannot be named PIC due to collision with -DPIC
    enum Model { Static, PIC_, DynamicNoPIC, ROPI, RWPI, ROPI_RWPI };
  }
 
  // Code model types.
  namespace CodeModel {
    // Sync changes with CodeGenCWrappers.h.
    enum Model { Tiny, Small, Kernel, Medium, Large };
  }
 
  namespace PICLevel {
    // This is used to map -fpic/-fPIC.
    enum Level { NotPIC=0, SmallPIC=1, BigPIC=2 };
  }
 
  namespace PIELevel {
    enum Level { Default=0, Small=1, Large=2 };
  }
 
  // TLS models.
  namespace TLSModel {
    enum Model {
      GeneralDynamic,
      LocalDynamic,
      InitialExec,
      LocalExec
    };
  }
 
  enum class ExceptionHandling : int {
    Default,    ///< Not specified; resolve to the target's default model
    None,       ///< No exception support
    DwarfCFI,   ///< DWARF-like instruction based exceptions
    SjLj,       ///< setjmp/longjmp based exceptions
    ARM,        ///< ARM EHABI
    WinEH,      ///< Windows Exception Handling
    Wasm,       ///< WebAssembly Exception Handling
    Emscripten, ///< Emscripten JavaScript-based exception handling
    AIX,        ///< AIX Exception Handling
    ZOS, ///< z/OS MVS Exception Handling. Very similar to DwarfCFI, but the
         ///< PPA1 is used instead of an .eh_frame section.
  };
 
  /// Returns the "exception-model" module flag spelling for an
  /// ExceptionHandling value. Default, AIX, and ZOS have no spelling and return
  /// "".
  inline StringRef getExceptionModelName(ExceptionHandling EH) {
    switch (EH) {
    case ExceptionHandling::None:
      return "none";
    case ExceptionHandling::DwarfCFI:
      return "dwarf";
    case ExceptionHandling::SjLj:
      return "sjlj";
    case ExceptionHandling::ARM:
      return "arm";
    case ExceptionHandling::WinEH:
      return "wineh";
    case ExceptionHandling::Wasm:
      return "wasm";
    case ExceptionHandling::Emscripten:
      return "emscripten";
    case ExceptionHandling::Default:
    case ExceptionHandling::AIX:
    case ExceptionHandling::ZOS:
      break;
    }
    return "";
  }
 
  /// Parses the string spelling used by the "exception-model" IR module flag
  /// into an ExceptionHandling value, returning std::nullopt if it does not
  /// name a supported exception model.
  inline std::optional<ExceptionHandling> parseExceptionModel(StringRef Name) {
    if (Name == "none")
      return ExceptionHandling::None;
    if (Name == "dwarf")
      return ExceptionHandling::DwarfCFI;
    if (Name == "sjlj")
      return ExceptionHandling::SjLj;
    if (Name == "arm")
      return ExceptionHandling::ARM;
    if (Name == "wineh")
      return ExceptionHandling::WinEH;
    if (Name == "wasm")
      return ExceptionHandling::Wasm;
    if (Name == "emscripten")
      return ExceptionHandling::Emscripten;
    return std::nullopt;
  }
 
  /// The floating-point format used for the target's "long double" type.
  enum class LongDoubleFormat {
    IEEEsingle,
    IEEEdouble,
    X87DoubleExtended,
    IEEEquad,
    PPCDoubleDouble,
  };
 
  /// Returns the IR floating-point type name for a LongDoubleFormat.
  inline StringRef getLongDoubleFormatName(LongDoubleFormat Format) {
    switch (Format) {
    case LongDoubleFormat::IEEEsingle:
      return "float";
    case LongDoubleFormat::IEEEdouble:
      return "double";
    case LongDoubleFormat::X87DoubleExtended:
      return "x86_fp80";
    case LongDoubleFormat::IEEEquad:
      return "fp128";
    case LongDoubleFormat::PPCDoubleDouble:
      return "ppc_fp128";
    }
    return "";
  }
 
  /// Parses an IR floating-point type name into a LongDoubleFormat, returning
  /// std::nullopt if it does not name a supported long double format.
  inline std::optional<LongDoubleFormat> parseLongDoubleFormat(StringRef Name) {
    if (Name == "float")
      return LongDoubleFormat::IEEEsingle;
    if (Name == "double")
      return LongDoubleFormat::IEEEdouble;
    if (Name == "x86_fp80")
      return LongDoubleFormat::X87DoubleExtended;
    if (Name == "fp128")
      return LongDoubleFormat::IEEEquad;
    if (Name == "ppc_fp128")
      return LongDoubleFormat::PPCDoubleDouble;
    return std::nullopt;
  }
 
  namespace FloatABI {
  enum ABIType {
    Default, // Target-specific (either soft or hard depending on triple, etc).
    Soft,    // Soft float.
    Hard     // Hard float.
  };
 
  /// Parse the string spelling used by the "float-abi" IR module flag into an
  /// ABIType.
  inline std::optional<ABIType> parseABIType(StringRef S) {
    if (S == "soft")
      return Soft;
    if (S == "hard")
      return Hard;
    return std::nullopt;
  }
 
  /// Returns the string spelling used by the "float-abi" IR module flag for a
  /// Soft or Hard ABIType. Default has no spelling.
  inline StringRef getABITypeName(ABIType ABI) {
    switch (ABI) {
    case Soft:
      return "soft";
    case Hard:
      return "hard";
    case Default:
      break;
    }
    return "";
  }
  } // namespace FloatABI
 
  /// The threading model to assume for lowering, e.g. of atomics.
  enum class ThreadModel {
    POSIX,  // POSIX Threads
    Single, // Single Threaded Environment
  };
 
  /// Parse the string spelling used by the "thread-model" IR module flag into a
  /// ThreadModel.
  inline std::optional<ThreadModel> parseThreadModel(StringRef S) {
    if (S == "posix")
      return ThreadModel::POSIX;
    if (S == "single")
      return ThreadModel::Single;
    return std::nullopt;
  }
 
  /// Returns the string spelling used by the "thread-model" IR module flag for
  /// a ThreadModel.
  inline StringRef getThreadModelName(ThreadModel TM) {
    switch (TM) {
    case ThreadModel::POSIX:
      return "posix";
    case ThreadModel::Single:
      return "single";
    }
    return "";
  }
 
  /// Identify a debugger for "tuning" the debug info.
  ///
  /// The "debugger tuning" concept allows us to present a more intuitive
  /// interface that unpacks into different sets of defaults for the various
  /// individual feature-flag settings, that suit the preferences of the
  /// various debuggers.  However, it's worth remembering that debuggers are
  /// not the only consumers of debug info, and some variations in DWARF might
  /// better be treated as target/platform issues. Fundamentally,
  /// o if the feature is useful (or not) to a particular debugger, regardless
  ///   of the target, that's a tuning decision;
  /// o if the feature is useful (or not) on a particular platform, regardless
  ///   of the debugger, that's a target decision.
  /// It's not impossible to see both factors in some specific case.
  enum class DebuggerKind {
    Default, ///< No specific tuning requested.
    GDB,     ///< Tune debug info for gdb.
    LLDB,    ///< Tune debug info for lldb.
    SCE,     ///< Tune debug info for SCE targets (e.g. PS4).
    DBX      ///< Tune debug info for dbx.
  };
 
  /// Parse the string spelling used by the "debugger-tuning" IR module flag
  /// into a DebuggerKind.
  inline std::optional<DebuggerKind> parseDebuggerTuning(StringRef S) {
    if (S == "gdb")
      return DebuggerKind::GDB;
    if (S == "lldb")
      return DebuggerKind::LLDB;
    if (S == "sce")
      return DebuggerKind::SCE;
    if (S == "dbx")
      return DebuggerKind::DBX;
    return std::nullopt;
  }
 
  /// Returns the string spelling used by the "debugger-tuning" IR module flag
  /// for a DebuggerKind.
  inline StringRef getDebuggerTuningName(DebuggerKind Tuning) {
    switch (Tuning) {
    case DebuggerKind::GDB:
      return "gdb";
    case DebuggerKind::LLDB:
      return "lldb";
    case DebuggerKind::SCE:
      return "sce";
    case DebuggerKind::DBX:
      return "dbx";
    case DebuggerKind::Default:
      break;
    }
    return "";
  }
 
  enum class EABI {
    Unknown,
    Default, // Default means not specified
    EABI4,   // Target-specific (either 4, 5 or gnu depending on triple).
    EABI5,
    GNU
  };
 
  /// Code generation optimization level.
  enum class CodeGenOptLevel {
    None = 0,      ///< -O0
    Less = 1,      ///< -O1
    Default = 2,   ///< -O2, -Os, -Oz
    Aggressive = 3 ///< -O3
  };
 
  namespace CodeGenOpt {
  /// Get the \c Level identified by the integer \p OL.
  ///
  /// Returns std::nullopt if \p OL is invalid.
  inline std::optional<CodeGenOptLevel> getLevel(int OL) {
    if (OL < 0 || OL > 3)
      return std::nullopt;
    return static_cast<CodeGenOptLevel>(OL);
  }
  /// Parse \p C as a single digit integer and get matching \c CodeGenLevel.
  ///
  /// Returns std::nullopt if the input is not a valid optimization level.
  inline std::optional<CodeGenOptLevel> parseLevel(char C) {
    if (C < '0')
      return std::nullopt;
    return getLevel(static_cast<int>(C - '0'));
  }
  } // namespace CodeGenOpt
 
  /// These enums are meant to be passed into addPassesToEmitFile to indicate
  /// what type of file to emit, and returned by it to indicate what type of
  /// file could actually be made.
  enum class CodeGenFileType {
    AssemblyFile,
    ObjectFile,
    Null // Do not emit any output.
  };
 
  /// Specify where the machine verifier runs in the codegen pipeline.
  enum class MachineVerifierMode {
    /// Never run the machine verifier.
    None,
    /// Run the machine verifier once, at the end of the pipeline.
    End,
    /// Run the machine verifier before and after every machine pass.
    Each
  };
 
  // Specify what functions should keep the frame pointer.
  enum class FramePointerKind {
    None,
    NonLeaf,
    All,
    Reserved,
    NonLeafNoReserve
  };
 
  // Specify what type of zeroing callee-used registers.
  namespace ZeroCallUsedRegs {
  const unsigned ONLY_USED = 1U << 1;
  const unsigned ONLY_GPR = 1U << 2;
  const unsigned ONLY_ARG = 1U << 3;
 
  enum class ZeroCallUsedRegsKind : unsigned int {
    // Don't zero any call-used regs.
    Skip = 1U << 0,
    // Only zeros call-used GPRs used in the fn and pass args.
    UsedGPRArg = ONLY_USED | ONLY_GPR | ONLY_ARG,
    // Only zeros call-used GPRs used in the fn.
    UsedGPR = ONLY_USED | ONLY_GPR,
    // Only zeros call-used regs used in the fn and pass args.
    UsedArg = ONLY_USED | ONLY_ARG,
    // Only zeros call-used regs used in the fn.
    Used = ONLY_USED,
    // Zeros all call-used GPRs that pass args.
    AllGPRArg = ONLY_GPR | ONLY_ARG,
    // Zeros all call-used GPRs.
    AllGPR = ONLY_GPR,
    // Zeros all call-used regs that pass args.
    AllArg = ONLY_ARG,
    // Zeros all call-used regs.
    All = 0,
  };
  } // namespace ZeroCallUsedRegs
 
  enum class UWTableKind {
    None = 0,  ///< No unwind table requested
    Sync = 1,  ///< "Synchronous" unwind tables
    Async = 2, ///< "Asynchronous" unwind tables (instr precise)
    Default = 2,
  };
 
  enum class FunctionReturnThunksKind : unsigned int {
    Keep = 0,    ///< No function return thunk.
    Extern = 1,  ///< Replace returns with jump to thunk, don't emit thunk.
    Invalid = 2, ///< Not used.
  };
 
  enum class WinX64EHUnwindMode {
    Default = 4, // Toolchain default/auto.
                 // Using '4' to avoid renumbering the existing values.
 
    V1 = 0,           // V1 unwind info.
    V2BestEffort = 1, // V2 where possible, fall back to V1.
    V2Required = 2,   // V2 required — error if a function cannot use V2.
    V3 = 3,           // V3 unwind info.
  };
 
  enum class ControlFlowGuardMode {
    // Don't enable Control Flow Guard.
    Disabled = 0,
    // Emit the Control Flow Guard tables in the binary, but don't emit any
    // checks.
    TableOnly = 1,
    // Enable Control Flow Guard checks and emit the tables.
    Enabled = 2,
  };
 
  enum class ControlFlowGuardMechanism {
    // Choose the mechanism automatically based on the target.
    Automatic = 0,
    Check = 1,
    Dispatch = 2,
  };
 
  } // namespace llvm
 
#endif