[NFC] Consolidate llvm::CodeGenOpt::Level handling

[scott.linder]

Summary

Add free functions llvm::CodeGenOpt::{getLevel,getID,parseLevel} to
provide common implementations for functionality that has been
duplicated in many places across the codebase.

[scott.linder]

I wasn't sure whether to include getID and unit-test it, or just drop it until it is used. If anyone has a preference let me know and I'll update the review.

[arsenm]

The error handling inconsistency is kind of annoying too but this is an improvement. I thought traditionally GCC accepted whatever big number you put after -O

[scott.linder]

llvm/include/llvm/Support/CodeGen.h

57

This is ABI breaking, so maybe we don't want/need to define the underlying type?

[arsenm]

llvm/include/llvm/Support/CodeGen.h

57

This isn't in the C API, and this isn't for a release branch so I don't think it matters

[barannikov88]

llvm/include/llvm/Support/CodeGen.h

57

Why did you need to restrict the underlying type?

72

Should return IDType.

llvm/tools/llvm-isel-fuzzer/llvm-isel-fuzzer.cpp

45

This disagrees with cl::init('2')

[barannikov88]

llvm/include/llvm/Support/CodeGen.h

67

As I can see, clients do not check for nullopt. Either add checks or replace this check with an assertion and drop std::optional (in this case parseLevel should be updated accordingly).

[scott.linder]

• Fix return type of getID
• Fix mistakenly updated option help text
• Add back in missing asserts

[scott.linder]

llvm/include/llvm/Support/CodeGen.h

57

There is no strict need, it just:

• Avoids potential UB (casting an out-of-range value to an enumeration type without a fixed underlying type is undefined); in practice there is plenty of UB in LLVM, and a bug here wouldn't be a particularly pernicious kind of UB anyway.
• Means users of the type might pack better (and we won't run out of 255 opt levels anytime soon).

I originally intended to change this to an enum class rather than a class in a namespace, but that is slightly more disruptive and should probably be done for every other enumeration defined here at the same time.

67

Good catch! I was working off of the old behavior of llvm::Optional and assuming the new std::optional was guaranteed to assert on dereference as well. I think the right interface is to expose the optional, so for the callsites which currently do the equivalent of asserting I will just carry over an explicit assert to the new version.

I posted to https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716/26 to discuss the issue more generally, as at least some of the patches which moved code from llvm::Optional to std::optional accidentally dropped assertions.

[barannikov88]

llvm/include/llvm/Support/CodeGen.h

57

Thanks for the explanation.

Means users of the type might pack better (and we won't run out of 255 opt levels anytime soon).

The downside is that int is usually more efficient.

Avoids potential UB [...]

cppreference says

Values of unscoped enumeration type are implicitly-convertible to integral types. If the underlying type is not fixed, the value is convertible to the first type from the following list able to hold their entire value range: int, unsigned int, ...

so casting to int should be safe.
Anyways, this is just a nit, feel free to ignore.

[mstorsjo]

llvm/include/llvm/Support/CodeGen.h

67

This causes massive amounts of warnings when built with GCC:

../include/llvm/Support/CodeGen.h:67:12: warning: comparison is always false due to limited range of data type [-Wtype-limits]
   67 |     if (ID < 0 || ID > 3)
      |         ~~~^~~

[scott.linder]

llvm/include/llvm/Support/CodeGen.h

67

Fixed in 2dc33713de7ceae3e28a13be1d72c862ec0efb2c

Thank you for reporting, sorry for the noise!

[scott.linder]

I also ended up changing the underlying type to int to resolve https://lab.llvm.org/buildbot/#/builders/61/builds/38754 , and I removed the getID function (with the implicit conversions it would never get used anyway).

[aaronpuchert]

flang/lib/Frontend/FrontendActions.cpp

590

Does this need llvm::?

../llvm-project/flang/lib/Frontend/FrontendActions.cpp:590:7: error: use of undeclared identifier 'CodeGenOpt'; did you mean 'llvm::CodeGenOpt'?
      CodeGenOpt::getLevel(CGOpts.OptimizationLevel);
      ^~~~~~~~~~
      llvm::CodeGenOpt
../llvm-project/llvm/include/llvm/Support/CodeGen.h:53:13: note: 'llvm::CodeGenOpt' declared here
  namespace CodeGenOpt {
            ^

See https://lab.llvm.org/buildbot/#/builders/191/builds/13832.

[scott.linder]

flang/lib/Frontend/FrontendActions.cpp

590

Yes, I just commited a1baa7a5c57ea3065f8f354d2fc758b3328040fd to fix this; I thought I was building flang locally but didn't verify it and clearly was not

Thank you and sorry for the noise!

clang/lib/CodeGen/BackendUtil.cpp

TLII->addVectorizableFunctionsFromVecLib(
         TargetLibraryInfoImpl::DarwinLibSystemM, TargetTriple);
     break;
   default:
     break;
   }
   return TLII;
 }
 
-static CodeGenOpt::Level getCGOptLevel(const CodeGenOptions &CodeGenOpts) {
-  switch (CodeGenOpts.OptimizationLevel) {
-  default:
-    llvm_unreachable("Invalid optimization level!");
-  case 0:
-    return CodeGenOpt::None;
-  case 1:
-    return CodeGenOpt::Less;
-  case 2:
-    return CodeGenOpt::Default; // O2/Os/Oz
-  case 3:
-    return CodeGenOpt::Aggressive;
-  }
-}
-
 static std::optional<llvm::CodeModel::Model>
 getCodeModel(const CodeGenOptions &CodeGenOpts) {
   unsigned CodeModel = llvm::StringSwitch<unsigned>(CodeGenOpts.CodeModel)
                            .Case("tiny", llvm::CodeModel::Tiny)
                            .Case("small", llvm::CodeModel::Small)
                            .Case("kernel", llvm::CodeModel::Kernel)
                            .Case("medium", llvm::CodeModel::Medium)
                            .Case("large", llvm::CodeModel::Large)
if (MustCreateTM)
       Diags.Report(diag::err_fe_unable_to_create_target) << Error;
     return;
   }
 
   std::optional<llvm::CodeModel::Model> CM = getCodeModel(CodeGenOpts);
   std::string FeaturesStr =
       llvm::join(TargetOpts.Features.begin(), TargetOpts.Features.end(), ",");
   llvm::Reloc::Model RM = CodeGenOpts.RelocationModel;
-  CodeGenOpt::Level OptLevel = getCGOptLevel(CodeGenOpts);
+  std::optional<CodeGenOpt::Level> OptLevelOrNone =
+      CodeGenOpt::getLevel(CodeGenOpts.OptimizationLevel);
+  assert(OptLevelOrNone && "Invalid optimization level!");
+  CodeGenOpt::Level OptLevel = *OptLevelOrNone;
 
   llvm::TargetOptions Options;
   if (!initTargetOptions(Diags, Options, CodeGenOpts, TargetOpts, LangOpts,
                          HSOpts))
     return;
   TM.reset(TheTarget->createTargetMachine(Triple, TargetOpts.CPU, FeaturesStr,
                                           Options, RM, CM, OptLevel));
 }
if (Error E = Conf.addSaveTemps(CGOpts.SaveTempsFilePrefix + ".",
                << '\n';
       });
     }
   }
   Conf.CPU = TOpts.CPU;
   Conf.CodeModel = getCodeModel(CGOpts);
   Conf.MAttrs = TOpts.Features;
   Conf.RelocModel = CGOpts.RelocationModel;
-  Conf.CGOptLevel = getCGOptLevel(CGOpts);
+  std::optional<CodeGenOpt::Level> OptLevelOrNone =
+      CodeGenOpt::getLevel(CGOpts.OptimizationLevel);
+  assert(OptLevelOrNone && "Invalid optimization level!");
+  Conf.CGOptLevel = *OptLevelOrNone;
   Conf.OptLevel = CGOpts.OptimizationLevel;
   initTargetOptions(Diags, Conf.Options, CGOpts, TOpts, LOpts, HeaderOpts);
   Conf.SampleProfile = std::move(SampleProfile);
   Conf.PTO.LoopUnrolling = CGOpts.UnrollLoops;
   // For historical reasons, loop interleaving is set to mirror setting for loop
   // unrolling.
   Conf.PTO.LoopInterleaving = CGOpts.UnrollLoops;
   Conf.PTO.LoopVectorization = CGOpts.VectorizeLoop;

clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp

 
 // Helper function to parse command line args and find the optimization level
 static CodeGenOpt::Level
 getOptLevel(const std::vector<const char *> &ExtraArgs) {
   // Find the optimization level from the command line args
   CodeGenOpt::Level OLvl = CodeGenOpt::Default;
   for (auto &A : ExtraArgs) {
     if (A[0] == '-' && A[1] == 'O') {
-      switch(A[2]) {
-        case '0': OLvl = CodeGenOpt::None; break;
-        case '1': OLvl = CodeGenOpt::Less; break;
-        case '2': OLvl = CodeGenOpt::Default; break;
-        case '3': OLvl = CodeGenOpt::Aggressive; break;
-        default:
-          errs() << "error: opt level must be between 0 and 3.\n";
-          std::exit(1);
+      if (auto Level = CodeGenOpt::parseLevel(A[2])) {
+        OLvl = *Level;
+      } else {
       }
     }
   }
   return OLvl;
 }
 
 static void ErrorAndExit(std::string message) {
   errs()<< "ERROR: " << message << "\n";

clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp

std::vector<std::string> getTargetFeatures(ArrayRef<OffloadFile> InputFiles) {
   for (StringRef Feature : llvm::reverse(Features)) {
     if (UsedFeatures.insert(Feature.drop_front()).second)
       UnifiedFeatures.push_back(Feature.str());
   }
 
   return UnifiedFeatures;
 }
 
-CodeGenOpt::Level getCGOptLevel(unsigned OptLevel) {
-  switch (OptLevel) {
-  case 0:
-    return CodeGenOpt::None;
-  case 1:
-    return CodeGenOpt::Less;
-  case 2:
-    return CodeGenOpt::Default;
-  case 3:
-    return CodeGenOpt::Aggressive;
-  }
-  llvm_unreachable("Invalid optimization level");
-}
-
 template <typename ModuleHook = function_ref<bool(size_t, const Module &)>>
 std::unique_ptr<lto::LTO> createLTO(
     const ArgList &Args, const std::vector<std::string> &Features,
     ModuleHook Hook = [](size_t, const Module &) { return true; }) {
   const llvm::Triple Triple(Args.getLastArgValue(OPT_triple_EQ));
   StringRef Arch = Args.getLastArgValue(OPT_arch_EQ);
   lto::Config Conf;
   lto::ThinBackend Backend;
   // TODO: Handle index-only thin-LTO
   Backend =
       lto::createInProcessThinBackend(llvm::heavyweight_hardware_concurrency());
 
   Conf.CPU = Arch.str();
   Conf.Options = codegen::InitTargetOptionsFromCodeGenFlags(Triple);
 
   StringRef OptLevel = Args.getLastArgValue(OPT_opt_level, "O2");
   Conf.MAttrs = Features;
-  Conf.CGOptLevel = getCGOptLevel(OptLevel[1] - '0');
+  std::optional<CodeGenOpt::Level> CGOptLevelOrNone =
+      CodeGenOpt::parseLevel(OptLevel[1]);
+  assert(CGOptLevelOrNone && "Invalid optimization level");
+  Conf.CGOptLevel = *CGOptLevelOrNone;
   Conf.OptLevel = OptLevel[1] - '0';
   if (Conf.OptLevel > 0)
     Conf.UseDefaultPipeline = true;
   Conf.DefaultTriple = Triple.getTriple();
 
   LTOError = false;
   Conf.DiagHandler = diagnosticHandler;
 

flang/lib/Frontend/FrontendActions.cpp

void CodeGenAction::generateLLVMIR() {
   if (!llvmModule) {
     unsigned diagID = ci.getDiagnostics().getCustomDiagID(
         clang::DiagnosticsEngine::Error, "failed to create the LLVM module");
     ci.getDiagnostics().Report(diagID);
     return;
   }
 }
 
-static llvm::CodeGenOpt::Level
-getCGOptLevel(const Fortran::frontend::CodeGenOptions &opts) {
-  switch (opts.OptimizationLevel) {
-  default:
-    llvm_unreachable("Invalid optimization level!");
-  case 0:
-    return llvm::CodeGenOpt::None;
-  case 1:
-    return llvm::CodeGenOpt::Less;
-  case 2:
-    return llvm::CodeGenOpt::Default;
-  case 3:
-    return llvm::CodeGenOpt::Aggressive;
-  }
-}
-
 void CodeGenAction::setUpTargetMachine() {
   CompilerInstance &ci = this->getInstance();
 
   const TargetOptions &targetOpts = ci.getInvocation().getTargetOpts();
   const std::string &theTriple = targetOpts.triple;
 
   // Create `Target`
   std::string error;
   const llvm::Target *theTarget =
       llvm::TargetRegistry::lookupTarget(theTriple, error);
   assert(theTarget && "Failed to create Target");
 
   // Create `TargetMachine`
   const auto &CGOpts = ci.getInvocation().getCodeGenOpts();
-  llvm::CodeGenOpt::Level OptLevel = getCGOptLevel(CGOpts);
+  std::optional<llvm::CodeGenOpt::Level> OptLevelOrNone =
+      CodeGenOpt::getLevel(CGOpts.OptimizationLevel);
+  assert(OptLevelOrNone && "Invalid optimization level!");
+  llvm::CodeGenOpt::Level OptLevel = *OptLevelOrNone;
   std::string featuresStr = llvm::join(targetOpts.featuresAsWritten.begin(),
                                        targetOpts.featuresAsWritten.end(), ",");
   tm.reset(theTarget->createTargetMachine(
       theTriple, /*CPU=*/targetOpts.cpu,
       /*Features=*/featuresStr, llvm::TargetOptions(),
       /*Reloc::Model=*/CGOpts.getRelocationModel(),
       /*CodeModel::Model=*/std::nullopt, OptLevel));
   assert(tm && "Failed to create TargetMachine");

llvm/include/llvm/Support/CodeGen.h

 //===-- 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 <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 };
   }
 
namespace TLSModel {
     enum Model {
       GeneralDynamic,
       LocalDynamic,
       InitialExec,
       LocalExec
     };
   }
 
-  // Code generation optimization level.
   namespace CodeGenOpt {
-    enum Level {
-      None = 0,      // -O0
-      Less = 1,      // -O1
-      Default = 2,   // -O2, -Os
-      Aggressive = 3 // -O3
-    };
+  /// Type for the unique integer IDs of code generation optimization levels.
+  using IDType = uint8_t;
+  /// Code generation optimization level.
+  enum Level : IDType {
+    None = 0,      ///< -O0
+    Less = 1,      ///< -O1
+    Default = 2,   ///< -O2, -Os
+    Aggressive = 3 ///< -O3
+  };
+  /// Get the \c Level identified by the integer \p ID.
+  ///
+  /// Returns std::nullopt if \p ID is invalid.
+  inline std::optional<Level> getLevel(IDType ID) {
+    if (ID < 0 || ID > 3)
+      return std::nullopt;
+    return static_cast<Level>(ID);
+  }
+  /// Get the integer \c ID of \p Level.
+  inline IDType getID(CodeGenOpt::Level Level) {
+    return static_cast<IDType>(Level);
+  }
+  /// Parse \p C as a single digit integer ID and get matching \c Level.
+  ///
+  /// Returns std::nullopt if the input is not a valid digit or not a valid ID.
+  inline std::optional<Level> parseLevel(char C) {
+    if (C < '0')
+      return std::nullopt;
+    return getLevel(static_cast<IDType>(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 CodeGenFileType {
     CGFT_AssemblyFile,
     CGFT_ObjectFile,
     CGFT_Null         // Do not emit any output.

llvm/lib/LTO/LTOCodeGenerator.cpp

void LTOCodeGenerator::setDebugInfo(lto_debug_model Debug) {
   }
   llvm_unreachable("Unknown debug format!");
 }
 
 void LTOCodeGenerator::setOptLevel(unsigned Level) {
   Config.OptLevel = Level;
   Config.PTO.LoopVectorization = Config.OptLevel > 1;
   Config.PTO.SLPVectorization = Config.OptLevel > 1;
-  switch (Config.OptLevel) {
-  case 0:
-    Config.CGOptLevel = CodeGenOpt::None;
-    return;
-  case 1:
-    Config.CGOptLevel = CodeGenOpt::Less;
-    return;
-  case 2:
-    Config.CGOptLevel = CodeGenOpt::Default;
-    return;
-  case 3:
-    Config.CGOptLevel = CodeGenOpt::Aggressive;
-    return;
-  }
-  llvm_unreachable("Unknown optimization level!");
+  std::optional<CodeGenOpt::Level> CGOptLevelOrNone =
+      CodeGenOpt::getLevel(Config.OptLevel);
+  assert(CGOptLevelOrNone && "Unknown optimization level!");
+  Config.CGOptLevel = *CGOptLevelOrNone;
 }
 
 bool LTOCodeGenerator::writeMergedModules(StringRef Path) {
   if (!determineTarget())
     return false;
 
   // We always run the verifier once on the merged module.
   verifyMergedModuleOnce();

llvm/tools/gold/gold-plugin.cpp

std::error_code EC =
         sys::fs::openFileForWrite(NewFilename, FD, sys::fs::CD_CreateAlways);
     if (EC)
       message(LDPL_FATAL, "Could not open file %s: %s", NewFilename.c_str(),
               EC.message().c_str());
   }
   return FD;
 }
 
-static CodeGenOpt::Level getCGOptLevel() {
-  switch (options::OptLevel) {
-  case 0:
-    return CodeGenOpt::None;
-  case 1:
-    return CodeGenOpt::Less;
-  case 2:
-    return CodeGenOpt::Default;
-  case 3:
-    return CodeGenOpt::Aggressive;
-  }
-  llvm_unreachable("Invalid optimization level");
-}
-
 /// Parse the thinlto_prefix_replace option into the \p OldPrefix and
 /// \p NewPrefix strings, if it was specified.
 static void getThinLTOOldAndNewPrefix(std::string &OldPrefix,
                                       std::string &NewPrefix) {
   StringRef PrefixReplace = options::thinlto_prefix_replace;
   assert(PrefixReplace.empty() || PrefixReplace.find(';') != StringRef::npos);
   auto Split = PrefixReplace.split(';');
   OldPrefix = std::string(Split.first);
static std::unique_ptr<LTO> createLTO(IndexWriteCallback OnIndexWrite,
   if (!codegen::getExplicitFunctionSections())
     Conf.Options.FunctionSections = SplitSections;
   if (!codegen::getExplicitDataSections())
     Conf.Options.DataSections = SplitSections;
 
   Conf.MAttrs = codegen::getMAttrs();
   Conf.RelocModel = RelocationModel;
   Conf.CodeModel = codegen::getExplicitCodeModel();
-  Conf.CGOptLevel = getCGOptLevel();
+  std::optional<CodeGenOpt::Level> CGOptLevelOrNone =
+      CodeGenOpt::getLevel(options::OptLevel);
+  assert(CGOptLevelOrNone && "Invalid optimization level");
+  Conf.CGOptLevel = *CGOptLevelOrNone;
   Conf.DisableVerify = options::DisableVerify;
   Conf.OptLevel = options::OptLevel;
   Conf.PTO.LoopVectorization = options::OptLevel > 1;
   Conf.PTO.SLPVectorization = options::OptLevel > 1;
   Conf.AlwaysEmitRegularLTOObj = !options::obj_path.empty();
 
   if (options::thinlto_index_only) {
     std::string OldPrefix, NewPrefix;

llvm/tools/llc/llc.cpp

PreserveComments("preserve-as-comments", cl::Hidden,
                      cl::desc("Preserve Comments in outputted assembly"),
                      cl::init(true));
 
 // Determine optimization level.
 static cl::opt<char>
     OptLevel("O",
              cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
                       "(default = '-O2')"),
-             cl::Prefix, cl::init(' '));
+             cl::Prefix, cl::init('2'));
 
 static cl::opt<std::string>
 TargetTriple("mtriple", cl::desc("Override target triple for module"));
 
 static cl::opt<std::string> SplitDwarfFile(
     "split-dwarf-file",
     cl::desc(
         "Specify the name of the .dwo file to encode in the DWARF output"));
static int compileModule(char **argv, LLVMContext &Context) {
   auto setMIRFunctionAttributes = [&CPUStr, &FeaturesStr](Function &F) {
     codegen::setFunctionAttributes(CPUStr, FeaturesStr, F);
   };
 
   auto MAttrs = codegen::getMAttrs();
   bool SkipModule =
       CPUStr == "help" || (!MAttrs.empty() && MAttrs.front() == "help");
 
-  CodeGenOpt::Level OLvl = CodeGenOpt::Default;
-  switch (OptLevel) {
-  default:
+  CodeGenOpt::Level OLvl;
+  if (auto Level = CodeGenOpt::parseLevel(OptLevel)) {
+    OLvl = *Level;
+  } else {
     WithColor::error(errs(), argv[0]) << "invalid optimization level.\n";
     return 1;
-  case ' ': break;
-  case '0': OLvl = CodeGenOpt::None; break;
-  case '1': OLvl = CodeGenOpt::Less; break;
-  case '2': OLvl = CodeGenOpt::Default; break;
-  case '3': OLvl = CodeGenOpt::Aggressive; break;
   }
 
   // Parse 'none' or '$major.$minor'. Disallow -binutils-version=0 because we
   // use that to indicate the MC default.
   if (!BinutilsVersion.empty() && BinutilsVersion != "none") {
     StringRef V = BinutilsVersion.getValue();
     unsigned Num;
     if (V.consumeInteger(10, Num) || Num == 0 ||

llvm/tools/lli/lli.cpp

ChildExecPath("mcjit-remote-process",
                          "for remote MCJIT execution.  If none is specified,"
                          "\n\tremote execution will be simulated in-process."),
                 cl::value_desc("filename"), cl::init(""));
 
   // Determine optimization level.
   cl::opt<char> OptLevel("O",
                          cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
                                   "(default = '-O2')"),
-                         cl::Prefix, cl::init(' '));
+                         cl::Prefix, cl::init('2'));
 
   cl::opt<std::string>
   TargetTriple("mtriple", cl::desc("Override target triple for module"));
 
   cl::opt<std::string>
   EntryFunc("entry-function",
             cl::desc("Specify the entry function (default = 'main') "
                      "of the executable"),
static void addCygMingExtraModule(ExecutionEngine &EE, LLVMContext &Context,
   Value *ReturnVal = ConstantInt::get(ReturnTy, 0);
   Builder.CreateRet(ReturnVal);
 
   // Add this new module to the ExecutionEngine.
   EE.addModule(std::move(M));
 }
 
 CodeGenOpt::Level getOptLevel() {
-  switch (OptLevel) {
-  default:
-    WithColor::error(errs(), "lli") << "invalid optimization level.\n";
-    exit(1);
-  case '0': return CodeGenOpt::None;
-  case '1': return CodeGenOpt::Less;
-  case ' ':
-  case '2': return CodeGenOpt::Default;
-  case '3': return CodeGenOpt::Aggressive;
-  }
-  llvm_unreachable("Unrecognized opt level.");
+  if (auto Level = CodeGenOpt::parseLevel(OptLevel))
+    return *Level;
 }
 
 [[noreturn]] static void reportError(SMDiagnostic Err, const char *ProgName) {
   Err.print(ProgName, errs());
   exit(1);
 }
 
 Error loadDylibs();

llvm/tools/llvm-isel-fuzzer/llvm-isel-fuzzer.cpp

 using namespace llvm;
 
 static codegen::RegisterCodeGenFlags CGF;
 
 static cl::opt<char>
     OptLevel("O",
              cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
                       "(default = '-O2')"),
-             cl::Prefix, cl::init(' '));
+             cl::Prefix, cl::init('2'));
 
 static cl::opt<std::string>
 TargetTriple("mtriple", cl::desc("Override target triple for module"));
 
 static std::unique_ptr<TargetMachine> TM;
 static std::unique_ptr<IRMutator> Mutator;
 
 std::unique_ptr<IRMutator> createISelMutator() {
if (!TheTarget) {
     errs() << argv[0] << ": " << Error;
     return 1;
   }
 
   // Set up the pipeline like llc does.
   std::string CPUStr = codegen::getCPUStr(),
               FeaturesStr = codegen::getFeaturesStr();
 
-  CodeGenOpt::Level OLvl = CodeGenOpt::Default;
-  switch (OptLevel) {
-  default:
+  CodeGenOpt::Level OLvl;
+  if (auto Level = CodeGenOpt::parseLevel(OptLevel)) {
+    OLvl = *Level;
+  } else {
     errs() << argv[0] << ": invalid optimization level.\n";
     return 1;
-  case ' ': break;
-  case '0': OLvl = CodeGenOpt::None; break;
-  case '1': OLvl = CodeGenOpt::Less; break;
-  case '2': OLvl = CodeGenOpt::Default; break;
-  case '3': OLvl = CodeGenOpt::Aggressive; break;
   }
 
   TargetOptions Options = codegen::InitTargetOptionsFromCodeGenFlags(TheTriple);
   TM.reset(TheTarget->createTargetMachine(
       TheTriple.getTriple(), CPUStr, FeaturesStr, Options,
       codegen::getExplicitRelocModel(), codegen::getExplicitCodeModel(), OLvl));
   assert(TM && "Could not allocate target machine!");
 
   // Make sure we print the summary and the current unit when LLVM errors out.
   install_fatal_error_handler(handleLLVMFatalError, nullptr);
 
   // Finally, create our mutator.
   Mutator = createISelMutator();
   return 0;
 }

llvm/tools/llvm-lto2/llvm-lto2.cpp

static int run(int argc, char **argv) {
   // Run a custom pipeline, if asked for.
   Conf.OptPipeline = OptPipeline;
   Conf.AAPipeline = AAPipeline;
 
   Conf.OptLevel = OptLevel - '0';
   Conf.Freestanding = EnableFreestanding;
   for (auto &PluginFN : PassPlugins)
     Conf.PassPlugins.push_back(PluginFN);
-  switch (CGOptLevel) {
-  case '0':
-    Conf.CGOptLevel = CodeGenOpt::None;
-    break;
-  case '1':
-    Conf.CGOptLevel = CodeGenOpt::Less;
-    break;
-  case '2':
-    Conf.CGOptLevel = CodeGenOpt::Default;
-    break;
-  case '3':
-    Conf.CGOptLevel = CodeGenOpt::Aggressive;
-    break;
-  default:
+  if (auto Level = CodeGenOpt::parseLevel(CGOptLevel)) {
+    Conf.CGOptLevel = *Level;
+  } else {
     llvm::errs() << "invalid cg optimization level: " << CGOptLevel << '\n';
     return 1;
   }
 
   if (auto FT = codegen::getExplicitFileType())
     Conf.CGFileType = *FT;
 
   Conf.OverrideTriple = OverrideTriple;

llvm/tools/lto/lto.cpp

thinlto_code_gen_t thinlto_create_codegen(void) {
   CodeGen->setTargetOptions(
       codegen::InitTargetOptionsFromCodeGenFlags(Triple()));
   CodeGen->setFreestanding(EnableFreestanding);
 
   if (OptLevel.getNumOccurrences()) {
     if (OptLevel < '0' || OptLevel > '3')
       report_fatal_error("Optimization level must be between 0 and 3");
     CodeGen->setOptLevel(OptLevel - '0');
-    switch (OptLevel) {
-    case '0':
-      CodeGen->setCodeGenOptLevel(CodeGenOpt::None);
-      break;
-    case '1':
-      CodeGen->setCodeGenOptLevel(CodeGenOpt::Less);
-      break;
-    case '2':
-      CodeGen->setCodeGenOptLevel(CodeGenOpt::Default);
-      break;
-    case '3':
-      CodeGen->setCodeGenOptLevel(CodeGenOpt::Aggressive);
-      break;
-    }
+    std::optional<CodeGenOpt::Level> CGOptLevelOrNone =
+        CodeGenOpt::getLevel(OptLevel - '0');
+    assert(CGOptLevelOrNone);
+    CodeGen->setCodeGenOptLevel(*CGOptLevelOrNone);
   }
   return wrap(CodeGen);
 }
 
 void thinlto_codegen_dispose(thinlto_code_gen_t cg) { delete unwrap(cg); }
 
 void thinlto_codegen_add_module(thinlto_code_gen_t cg, const char *Identifier,
                                 const char *Data, int Length) {

openmp/libomptarget/plugins-nextgen/common/PluginInterface/JIT.cpp

 createModuleFromImage(const __tgt_device_image &Image, LLVMContext &Context) {
   StringRef Data((const char *)Image.ImageStart,
                  target::getPtrDiff(Image.ImageEnd, Image.ImageStart));
   std::unique_ptr<MemoryBuffer> MB = MemoryBuffer::getMemBuffer(
       Data, /* BufferName */ "", /* RequiresNullTerminator */ false);
   return createModuleFromMemoryBuffer(MB, Context);
 }
 
-CodeGenOpt::Level getCGOptLevel(unsigned OptLevel) {
-  switch (OptLevel) {
-  case 0:
-    return CodeGenOpt::None;
-  case 1:
-    return CodeGenOpt::Less;
-  case 2:
-    return CodeGenOpt::Default;
-  case 3:
-    return CodeGenOpt::Aggressive;
-  }
-  llvm_unreachable("Invalid optimization level");
-}
-
 OptimizationLevel getOptLevel(unsigned OptLevel) {
   switch (OptLevel) {
   case 0:
     return OptimizationLevel::O0;
   case 1:
     return OptimizationLevel::O1;
   case 2:
     return OptimizationLevel::O2;
   case 3:
     return OptimizationLevel::O3;
   }
   llvm_unreachable("Invalid optimization level");
 }
 
 Expected<std::unique_ptr<TargetMachine>>
 createTargetMachine(Module &M, std::string CPU, unsigned OptLevel) {
   Triple TT(M.getTargetTriple());
-  CodeGenOpt::Level CGOptLevel = getCGOptLevel(OptLevel);
+  std::optional<CodeGenOpt::Level> CGOptLevelOrNone =
+      CodeGenOpt::getLevel(OptLevel);
+  assert(CGOptLevelOrNone && "Invalid optimization level");
+  CodeGenOpt::Level CGOptLevel = *CGOptLevelOrNone;
 
   std::string Msg;
   const Target *T = TargetRegistry::lookupTarget(M.getTargetTriple(), Msg);
   if (!T)
     return make_error<StringError>(Msg, inconvertibleErrorCode());
 
   SubtargetFeatures Features;
   Features.getDefaultSubtargetFeatures(TT);