[LTO] Allow passing -Os/-Oz as the optimization level

[aeubanks]

update

[fhahn]

Could you add tests on the LLVM side for the new options as well? See also D95541

[aeubanks]

add more tests

[pcc]

Please see D63976 where we rejected a similar change in favor of just letting this be controllable at compile time.

To the extent that the pass pipeline is affected by the size optimization level, I think we should change the passes so that they respect the optsize/minsize attributes.

[thevinster]

lld/Common/Args.cpp

29

nit: getOptLevel seems a bit too generic for something that's LTO specific. The MachO port has the concept of passing an opt level that generates more efficient opcodes. Suggestions are welcome here - perhaps getLTOOptLevel would be better here?

[MaskRay]

D72404 has some comments why the -Os/-Oz levels are discouraged.

[aeubanks]

I posted an RFC a while back for basically removing size levels from optimization levels but never seriously looked into it: https://groups.google.com/g/llvm-dev/c/NrZsR8OZTts/m/P5t14TKaAQAJ

clang/lib/CodeGen/BackendUtil.cpp

if (Error E = Conf.addSaveTemps(CGOpts.SaveTempsFilePrefix + ".",
       });
     }
   }
   Conf.CPU = TOpts.CPU;
   Conf.CodeModel = getCodeModel(CGOpts);
   Conf.MAttrs = TOpts.Features;
   Conf.RelocModel = CGOpts.RelocationModel;
   Conf.CGOptLevel = getCGOptLevel(CGOpts);
-  Conf.OptLevel = CGOpts.OptimizationLevel;
+  Conf.OptLevel = mapToLevel(CGOpts);
   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;
   Conf.PTO.SLPVectorization = CGOpts.VectorizeSLP;

lld/COFF/Config.h

 //===- Config.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_CONFIG_H
 #define LLD_COFF_CONFIG_H
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/COFF.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Support/CachePruning.h"
 #include <cstdint>
 #include <map>
 #include <set>
 #include <string>
 
 namespace lld {
 namespace coff {
struct Configuration {
 
   // Used for SafeSEH.
   bool safeSEH = false;
   Symbol *sehTable = nullptr;
   Symbol *sehCount = nullptr;
   bool noSEH = false;
 
   // Used for /opt:lldlto=N
-  unsigned ltoo = 2;
+  llvm::OptimizationLevel ltoo = llvm::OptimizationLevel::O2;
 
   // Used for /opt:lldltojobs=N
   std::string thinLTOJobs;
   // Used for /opt:lldltopartitions=N
   unsigned ltoPartitions = 1;
 
   // Used for /opt:lldltocache=path
   StringRef ltoCache;

lld/COFF/Driver.cpp

 #include "llvm/LTO/LTO.h"
 #include "llvm/Object/ArchiveWriter.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/COFFModuleDefinition.h"
 #include "llvm/Object/WindowsMachineFlag.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Parallel.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
for (StringRef s : vec) {
       } else if (s == "noltonewpassmanager") {
         ltoNewPM = false;
       } else if (s == "ltodebugpassmanager") {
         ltoDebugPM = true;
       } else if (s == "noltodebugpassmanager") {
         ltoDebugPM = false;
       } else if (s.startswith("lldlto=")) {
         StringRef optLevel = s.substr(7);
-        if (optLevel.getAsInteger(10, config->ltoo) || config->ltoo > 3)
+        Optional<OptimizationLevel> OL;
+        if (optLevel.size() == 1)
+          OL = OptimizationLevel::forChar(optLevel[0]);
+        if (OL)
+          config->ltoo = *OL;
+        else
           error("/opt:lldlto: invalid optimization level: " + optLevel);
       } else if (s.startswith("lldltojobs=")) {
         StringRef jobs = s.substr(11);
         if (!get_threadpool_strategy(jobs))
           error("/opt:lldltojobs: invalid job count: " + jobs);
         config->thinLTOJobs = jobs.str();
       } else if (s.startswith("lldltopartitions=")) {
         StringRef n = s.substr(17);

lld/Common/Args.cpp

 //===- Args.cpp -----------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/Common/Args.h"
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Option/ArgList.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Support/Path.h"
 
 using namespace llvm;
 using namespace lld;
 
 // TODO(sbc): Remove this once CGOptLevel can be set completely based on bitcode
 // function metadata.
-CodeGenOpt::Level lld::args::getCGOptLevel(int optLevelLTO) {
-  if (optLevelLTO == 3)
+CodeGenOpt::Level lld::args::getCGOptLevel(OptimizationLevel optLevelLTO) {
+  if (optLevelLTO.getSpeedupLevel() == 3)
     return CodeGenOpt::Aggressive;
-  assert(optLevelLTO < 3);
   return CodeGenOpt::Default;
 }
 
+OptimizationLevel args::getOptLevel(llvm::opt::InputArgList &args,
+                                    unsigned int key,
+                                    llvm::OptimizationLevel Default) {
+  Optional<OptimizationLevel> OL;
+  if (opt::Arg *arg = args.getLastArg(key)) {
+    std::string lto = arg->getValue();
+    if (lto.size() == 1)
+      OL = llvm::OptimizationLevel::forChar(lto[0]);
+    if (!OL)
+      error("invalid optimization level for LTO: " + lto);
+    return OL.getValueOr(Default);
+  }
+  return Default;
+}
+
 static int64_t getInteger(opt::InputArgList &args, unsigned key,
                           int64_t Default, unsigned base) {
   auto *a = args.getLastArg(key);
   if (!a)
     return Default;
 
   int64_t v;
   StringRef s = a->getValue();

lld/Common/CMakeLists.txt

add_lld_library(lldCommon
 
   LINK_COMPONENTS
   Codegen
   Core
   DebugInfoDWARF
   Demangle
   MC
   Option
+  Passes
   Support
   Target
 
   LINK_LIBS
   ${LLD_SYSTEM_LIBS}
 
   DEPENDS
   intrinsics_gen
   )

lld/ELF/Config.h

 
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/ELF.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/GlobPattern.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include <atomic>
 #include <vector>
 
struct Configuration {
   ELFKind ekind = ELFNoneKind;
   uint16_t emachine = llvm::ELF::EM_NONE;
   llvm::Optional<uint64_t> imageBase;
   uint64_t commonPageSize;
   uint64_t maxPageSize;
   uint64_t mipsGotSize;
   uint64_t zStackSize;
   unsigned ltoPartitions;
-  unsigned ltoo;
+  llvm::OptimizationLevel ltoo;
   unsigned optimize;
   StringRef thinLTOJobs;
   unsigned timeTraceGranularity;
   int32_t splitStackAdjustSize;
 
   // The following config options do not directly correspond to any
   // particular command line options.
 

lld/ELF/Driver.cpp

 #include "lld/Common/Strings.h"
 #include "lld/Common/TargetOptionsCommandFlags.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/LTO/LTO.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Remarks/HotnessThresholdParser.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/GlobPattern.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/Parallel.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TarWriter.h"
static void readConfigs(opt::InputArgList &args) {
   config->ltoEmitAsm = args.hasArg(OPT_lto_emit_asm);
   config->ltoNewPassManager =
       args.hasFlag(OPT_no_lto_legacy_pass_manager, OPT_lto_legacy_pass_manager,
                    LLVM_ENABLE_NEW_PASS_MANAGER);
   config->ltoNewPmPasses = args.getLastArgValue(OPT_lto_newpm_passes);
   config->ltoWholeProgramVisibility =
       args.hasFlag(OPT_lto_whole_program_visibility,
                    OPT_no_lto_whole_program_visibility, false);
-  config->ltoo = args::getInteger(args, OPT_lto_O, 2);
+  config->ltoo =
+      args::getOptLevel(args, OPT_lto_O, llvm::OptimizationLevel::O2);
   config->ltoObjPath = args.getLastArgValue(OPT_lto_obj_path_eq);
   config->ltoPartitions = args::getInteger(args, OPT_lto_partitions, 1);
   config->ltoSampleProfile = args.getLastArgValue(OPT_lto_sample_profile);
   config->ltoBasicBlockSections =
       args.getLastArgValue(OPT_lto_basic_block_sections);
   config->ltoUniqueBasicBlockSectionNames =
       args.hasFlag(OPT_lto_unique_basic_block_section_names,
                    OPT_no_lto_unique_basic_block_section_names, false);
if (!llvm::to_integer(v, threads, 0) || threads == 0)
       error(arg->getSpelling() + ": expected a positive integer, but got '" +
             arg->getValue() + "'");
     parallel::strategy = hardware_concurrency(threads);
     config->thinLTOJobs = v;
   }
   if (auto *arg = args.getLastArg(OPT_thinlto_jobs))
     config->thinLTOJobs = arg->getValue();
 
-  if (config->ltoo > 3)
-    error("invalid optimization level for LTO: " + Twine(config->ltoo));
   if (config->ltoPartitions == 0)
     error("--lto-partitions: number of threads must be > 0");
   if (!get_threadpool_strategy(config->thinLTOJobs))
     error("--thinlto-jobs: invalid job count: " + config->thinLTOJobs);
 
   if (config->splitStackAdjustSize < 0)
     error("--split-stack-adjust-size: size must be >= 0");
 

lld/ELF/LTO.cpp

static lto::Config createConfig() {
   c.CodeModel = getCodeModelFromCMModel();
   c.DisableVerify = config->disableVerify;
   c.DiagHandler = diagnosticHandler;
   c.OptLevel = config->ltoo;
   c.CPU = getCPUStr();
   c.MAttrs = getMAttrs();
   c.CGOptLevel = args::getCGOptLevel(config->ltoo);
 
-  c.PTO.LoopVectorization = c.OptLevel > 1;
-  c.PTO.SLPVectorization = c.OptLevel > 1;
+  c.PTO.LoopVectorization = c.OptLevel.getSpeedupLevel() > 1;
+  c.PTO.SLPVectorization = c.OptLevel.getSpeedupLevel() > 1;
 
   // Set up a custom pipeline if we've been asked to.
   c.OptPipeline = std::string(config->ltoNewPmPasses);
   c.AAPipeline = std::string(config->ltoAAPipeline);
 
   // Set up optimization remarks if we've been asked to.
   c.RemarksFilename = std::string(config->optRemarksFilename);
   c.RemarksPasses = std::string(config->optRemarksPasses);

lld/MachO/Config.h

 #define LLD_MACHO_CONFIG_H
 
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/MachO.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/GlobPattern.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/TextAPI/Architecture.h"
 #include "llvm/TextAPI/Platform.h"
 #include "llvm/TextAPI/Target.h"
 
 #include <vector>
struct Configuration {
   llvm::StringRef outputFile;
   llvm::StringRef finalOutput;
 
   llvm::StringRef installName;
   llvm::StringRef mapFile;
   llvm::StringRef ltoObjPath;
   llvm::StringRef thinLTOJobs;
   llvm::StringRef umbrella;
-  uint32_t ltoo = 2;
+  llvm::OptimizationLevel ltoo = llvm::OptimizationLevel::O2;
   llvm::CachePruningPolicy thinLTOCachePolicy;
   llvm::StringRef thinLTOCacheDir;
   bool deadStripDylibs = false;
   bool demangle = false;
   bool deadStrip = false;
   bool errorForArchMismatch = false;
   PlatformInfo platformInfo;
   NamespaceKind namespaceKind = NamespaceKind::twolevel;

lld/MachO/Driver.cpp

if (const Arg *arg = args.getLastArg(OPT_umbrella)) {
     if (config->outputType != MH_DYLIB)
       warn("-umbrella used, but not creating dylib");
     config->umbrella = arg->getValue();
   }
   config->ltoObjPath = args.getLastArgValue(OPT_object_path_lto);
   config->ltoNewPassManager =
       args.hasFlag(OPT_no_lto_legacy_pass_manager, OPT_lto_legacy_pass_manager,
                    LLVM_ENABLE_NEW_PASS_MANAGER);
-  config->ltoo = args::getInteger(args, OPT_lto_O, 2);
-  if (config->ltoo > 3)
-    error("--lto-O: invalid optimization level: " + Twine(config->ltoo));
+  config->ltoo =
+      args::getOptLevel(args, OPT_lto_O, llvm::OptimizationLevel::O2);
   config->thinLTOCacheDir = args.getLastArgValue(OPT_cache_path_lto);
   config->thinLTOCachePolicy = getLTOCachePolicy(args);
   config->runtimePaths = args::getStrings(args, OPT_rpath);
   config->allLoad = args.hasArg(OPT_all_load);
   config->archMultiple = args.hasArg(OPT_arch_multiple);
   config->applicationExtension = args.hasFlag(
       OPT_application_extension, OPT_no_application_extension, false);
   config->exportDynamic = args.hasArg(OPT_export_dynamic);

lld/include/lld/Common/Args.h

 //===- Args.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ARGS_H
 #define LLD_ARGS_H
 
 #include "lld/Common/LLVM.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <vector>
 
 namespace llvm {
 namespace opt {
 class InputArgList;
 }
 } // namespace llvm
 
 namespace lld {
 namespace args {
 
-llvm::CodeGenOpt::Level getCGOptLevel(int optLevelLTO);
+llvm::CodeGenOpt::Level getCGOptLevel(llvm::OptimizationLevel optLevelLTO);
+llvm::OptimizationLevel getOptLevel(llvm::opt::InputArgList &args, unsigned key,
+                                    llvm::OptimizationLevel Default);
 
 int64_t getInteger(llvm::opt::InputArgList &args, unsigned key,
                    int64_t Default);
 
 int64_t getHex(llvm::opt::InputArgList &args, unsigned key, int64_t Default);
 
 std::vector<StringRef> getStrings(llvm::opt::InputArgList &args, int id);
 

lld/test/COFF/lto-opt-level.ll

 ; REQUIRES: x86
 ; RUN: llvm-as -o %t.obj %s
 ; RUN: lld-link /out:%t0.exe /entry:main /subsystem:console /opt:lldlto=0 /lldmap:%t0.map %t.obj
 ; RUN: FileCheck --check-prefix=CHECK-O0 %s < %t0.map
 ; RUN: lld-link /out:%t2.exe /entry:main /subsystem:console /opt:lldlto=2 /lldmap:%t2.map %t.obj
 ; RUN: FileCheck --check-prefix=CHECK-O2 %s < %t2.map
+; RUN: lld-link /out:%t2.exe /entry:main /subsystem:console /opt:lldlto=s /lldmap:%t2.map %t.obj
+; RUN: FileCheck --check-prefix=CHECK-O2 %s < %t2.map
+; RUN: lld-link /out:%t2.exe /entry:main /subsystem:console /opt:lldlto=z /lldmap:%t2.map %t.obj
+; RUN: FileCheck --check-prefix=CHECK-O2 %s < %t2.map
 ; RUN: lld-link /out:%t2a.exe /entry:main /subsystem:console /lldmap:%t2a.map %t.obj
 ; RUN: FileCheck --check-prefix=CHECK-O2 %s < %t2a.map
+; RUN: not lld-link /out:%t2.exe /entry:main /subsystem:console /opt:lldlto=a /lldmap:%t2.map %t.obj 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR-A
+; RUN: not lld-link /out:%t2.exe /entry:main /subsystem:console /opt:lldlto=abc /lldmap:%t2.map %t.obj 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR-ABC
+
+; CHECK-ERROR-A: invalid optimization level: a
+; CHECK-ERROR-ABC: invalid optimization level: abc
 
 target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
 ; CHECK-O0: foo
 ; CHECK-O2-NOT: foo
 define internal void @foo() {
   ret void
 }
 
 define void @main() {
   call void @foo()
   ret void
 }

lld/test/ELF/lto/opt-level.ll

 ; REQUIRES: x86
 ; RUN: llvm-as -o %t.o %s
 ; RUN: ld.lld -o %t0 -e main --lto-O0 %t.o
 ; RUN: llvm-nm %t0 | FileCheck --check-prefix=CHECK-O0 %s
 ; RUN: ld.lld -o %t0 -e main --plugin-opt=O0 %t.o
 ; RUN: llvm-nm %t0 | FileCheck --check-prefix=CHECK-O0 %s
 ; RUN: ld.lld -o %t2 -e main --lto-O2 %t.o
 ; RUN: llvm-nm %t2 | FileCheck --check-prefix=CHECK-O2 %s
 ; RUN: ld.lld -o %t2a -e main %t.o
 ; RUN: llvm-nm %t2a | FileCheck --check-prefix=CHECK-O2 %s
 ; RUN: ld.lld -o %t2 -e main %t.o --plugin-opt O2
 ; RUN: llvm-nm %t2 | FileCheck --check-prefix=CHECK-O2 %s
+; RUN: ld.lld -o %t2 -e main --lto-Os %t.o
+; RUN: llvm-nm %t2 | FileCheck --check-prefix=CHECK-O2 %s
+; RUN: ld.lld -o %t2 -e main --lto-Oz %t.o
+; RUN: llvm-nm %t2 | FileCheck --check-prefix=CHECK-O2 %s
 
 ; Reject invalid optimization levels.
 ; RUN: not ld.lld -o /dev/null -e main --lto-O6 %t.o 2>&1 | \
 ; RUN:   FileCheck --check-prefix=INVALID1 %s
 ; INVALID1: invalid optimization level for LTO: 6
 ; RUN: not ld.lld -o /dev/null -e main --plugin-opt=O6 %t.o 2>&1 | \
 ; RUN:   FileCheck --check-prefix=INVALID1 %s
 ; RUN: not ld.lld -o /dev/null -e main --plugin-opt=Ofoo %t.o 2>&1 | \
 ; RUN:   FileCheck --check-prefix=INVALID2 %s
-; INVALID2: --plugin-opt=Ofoo: number expected, but got 'foo'
+; INVALID2: invalid optimization level for LTO: foo
 
 ; RUN: not ld.lld -o /dev/null -e main --lto-O-1 %t.o 2>&1 | \
 ; RUN:   FileCheck --check-prefix=INVALIDNEGATIVE1 %s
-; INVALIDNEGATIVE1: invalid optimization level for LTO: 4294967295
+; INVALIDNEGATIVE1: invalid optimization level for LTO: -1
 ; RUN: not ld.lld -o /dev/null -e main --plugin-opt=O-1 %t.o 2>&1 | \
 ; RUN:   FileCheck --check-prefix=INVALIDNEGATIVE2 %s
-; INVALIDNEGATIVE2: invalid optimization level for LTO: 4294967295
+; INVALIDNEGATIVE2: invalid optimization level for LTO: -1
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK-O0: foo
 ; CHECK-O2-NOT: foo
 define internal void @foo() {
   ret void
 }
 
 define void @main() {
   call void @foo()
   ret void
 }

lld/test/MachO/lto-opt-level.ll

 ; REQUIRES: x86
 
 ; RUN: rm -rf %t; mkdir %t
 ; RUN: llvm-as  %s -o %t/test.o
 
 ; RUN: %lld %t/test.o --lto-O0 -o %t/test
 ; RUN: llvm-nm -pa %t/test | FileCheck %s --check-prefixes=CHECK-O0
 
 ; RUN: %lld %t/test.o --lto-O2 -o %t/test
 ; RUN: llvm-nm -pa %t/test | FileCheck %s --check-prefixes=CHECK-O2
 
+; RUN: %lld %t/test.o --lto-Os -o %t/test
+; RUN: llvm-nm -pa %t/test | FileCheck %s --check-prefixes=CHECK-O2
+
+; RUN: %lld %t/test.o --lto-Oz -o %t/test
+; RUN: llvm-nm -pa %t/test | FileCheck %s --check-prefixes=CHECK-O2
+
 ; RUN: %lld %t/test.o -o %t/test
 ; RUN: llvm-nm -pa %t/test | FileCheck %s --check-prefixes=CHECK-O2
 
 ; CHECK-O0: foo
 ; CHECK-O2-NOT: foo
 
 target triple = "x86_64-apple-macosx10.15.0"
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"

lld/test/wasm/lto/opt-level.ll

 ; RUN: llvm-as -o %t.o %s
 ; RUN: wasm-ld -o %t0 -e main --lto-O0 %t.o
 ; RUN: obj2yaml %t0 | FileCheck --check-prefix=CHECK-O0 %s
 ; RUN: wasm-ld -o %t2 -e main --lto-O2 %t.o
 ; RUN: obj2yaml %t2 | FileCheck --check-prefix=CHECK-O2 %s
+; RUN: wasm-ld -o %t2 -e main --lto-Os %t.o
+; RUN: obj2yaml %t2 | FileCheck --check-prefix=CHECK-O2 %s
+; RUN: wasm-ld -o %t2 -e main --lto-Oz %t.o
+; RUN: obj2yaml %t2 | FileCheck --check-prefix=CHECK-O2 %s
 ; RUN: wasm-ld -o %t2a -e main %t.o
 ; RUN: obj2yaml %t2a | FileCheck --check-prefix=CHECK-O2 %s
 
 ; Reject invalid optimization levels.
 ; RUN: not wasm-ld -o %t3 -e main --lto-O6 %t.o 2>&1 | \
 ; RUN:   FileCheck --check-prefix=INVALID %s
 ; INVALID: invalid optimization level for LTO: 6
 
 ; RUN: not wasm-ld -o %t3 -e main --lto-O-1 %t.o 2>&1 | \
 ; RUN:   FileCheck --check-prefix=INVALIDNEGATIVE %s
-; INVALIDNEGATIVE: invalid optimization level for LTO: 4294967295
+; INVALIDNEGATIVE: invalid optimization level for LTO: -1
 
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; CHECK-O0: Name: foo
 ; CHECK-O2-NOT: Name: foo
 define internal void @foo() {
   ret void
 }
 
 define void @main() {
   call void @foo()
   ret void
 }

lld/wasm/Config.h

 //===- Config.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_CONFIG_H
 #define LLD_WASM_CONFIG_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/Wasm.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Support/CachePruning.h"
 
 namespace lld {
 namespace wasm {
 
 // For --unresolved-symbols.
 enum class UnresolvedPolicy { ReportError, Warn, Ignore };
 
struct Configuration {
   bool stripDebug;
   bool stackFirst;
   bool trace;
   uint64_t globalBase;
   uint64_t initialMemory;
   uint64_t maxMemory;
   uint64_t zStackSize;
   unsigned ltoPartitions;
-  unsigned ltoo;
+  llvm::OptimizationLevel ltoo = llvm::OptimizationLevel::O2;
   unsigned optimize;
   llvm::StringRef thinLTOJobs;
   bool ltoNewPassManager;
   bool ltoDebugPassManager;
   UnresolvedPolicy unresolvedSymbols;
 
   llvm::StringRef entry;
   llvm::StringRef mapFile;

lld/wasm/Driver.cpp

static void readConfigs(opt::InputArgList &args) {
   config->exportTable = args.hasArg(OPT_export_table);
   config->growableTable = args.hasArg(OPT_growable_table);
   errorHandler().fatalWarnings =
       args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
   config->importMemory = args.hasArg(OPT_import_memory);
   config->sharedMemory = args.hasArg(OPT_shared_memory);
   config->importTable = args.hasArg(OPT_import_table);
   config->importUndefined = args.hasArg(OPT_import_undefined);
-  config->ltoo = args::getInteger(args, OPT_lto_O, 2);
+  config->ltoo =
+      args::getOptLevel(args, OPT_lto_O, llvm::OptimizationLevel::O2);
   config->ltoPartitions = args::getInteger(args, OPT_lto_partitions, 1);
   config->ltoNewPassManager =
       args.hasFlag(OPT_no_lto_legacy_pass_manager, OPT_lto_legacy_pass_manager,
                    LLVM_ENABLE_NEW_PASS_MANAGER);
   config->ltoDebugPassManager = args.hasArg(OPT_lto_debug_pass_manager);
   config->mapFile = args.getLastArgValue(OPT_Map);
   config->optimize = args::getInteger(args, OPT_O, 1);
   config->outputFile = args.getLastArgValue(OPT_o);

 
 // Some command line options or some combinations of them are not allowed.
 // This function checks for such errors.
 static void checkOptions(opt::InputArgList &args) {
   if (!config->stripDebug && !config->stripAll && config->compressRelocations)
     error("--compress-relocations is incompatible with output debug"
           " information. Please pass --strip-debug or --strip-all");
 
-  if (config->ltoo > 3)
-    error("invalid optimization level for LTO: " + Twine(config->ltoo));
   if (config->ltoPartitions == 0)
     error("--lto-partitions: number of threads must be > 0");
   if (!get_threadpool_strategy(config->thinLTOJobs))
     error("--thinlto-jobs: invalid job count: " + config->thinLTOJobs);
 
   if (config->pie && config->shared)
     error("-shared and -pie may not be used together");
 

llvm/include/llvm/LTO/Config.h

 #define LLVM_LTO_CONFIG_H
 
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Passes/PassBuilder.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Target/TargetOptions.h"
 
 #include <functional>
 
 namespace llvm {
 
struct Config {
   std::vector<std::string> MAttrs;
   std::vector<std::string> PassPlugins;
   /// For adding passes that run right before codegen.
   std::function<void(legacy::PassManager &)> PreCodeGenPassesHook;
   Optional<Reloc::Model> RelocModel = Reloc::PIC_;
   Optional<CodeModel::Model> CodeModel = None;
   CodeGenOpt::Level CGOptLevel = CodeGenOpt::Default;
   CodeGenFileType CGFileType = CGFT_ObjectFile;
-  unsigned OptLevel = 2;
+  OptimizationLevel OptLevel = OptimizationLevel::O2;
   bool DisableVerify = false;
 
   /// Use the new pass manager
   bool UseNewPM = LLVM_ENABLE_NEW_PASS_MANAGER;
 
   /// Flag to indicate that the optimizer should not assume builtins are present
   /// on the target.
   bool Freestanding = false;

llvm/include/llvm/LTO/legacy/LTOCodeGenerator.h

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/Module.h"
 #include "llvm/LTO/Config.h"
 #include "llvm/LTO/LTO.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include <string>
 #include <vector>
 
struct LTOCodeGenerator {
   }
 
   /// Set the file type to be emitted (assembly or object code).
   /// The default is CGFT_ObjectFile.
   void setFileType(CodeGenFileType FT) { Config.CGFileType = FT; }
 
   void setCpu(StringRef MCpu) { Config.CPU = std::string(MCpu); }
   void setAttrs(std::vector<std::string> MAttrs) { Config.MAttrs = MAttrs; }
-  void setOptLevel(unsigned OptLevel);
+  void setOptLevel(OptimizationLevel OptLevel);
 
   void setShouldInternalize(bool Value) { ShouldInternalize = Value; }
   void setShouldEmbedUselists(bool Value) { ShouldEmbedUselists = Value; }
 
   /// Restore linkage of globals
   ///
   /// When set, the linkage of globals will be restored prior to code
   /// generation. That is, a global symbol that had external linkage prior to

llvm/include/llvm/LTO/legacy/ThinLTOCodeGenerator.h

 #ifndef LLVM_LTO_LEGACY_THINLTOCODEGENERATOR_H
 #define LLVM_LTO_LEGACY_THINLTOCODEGENERATOR_H
 
 #include "llvm-c/lto.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/LTO/LTO.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Target/TargetOptions.h"
 
 #include <string>
 
 namespace llvm {
public:
   }
 
   /// CodeGen optimization level
   void setCodeGenOptLevel(CodeGenOpt::Level CGOptLevel) {
     TMBuilder.CGOptLevel = CGOptLevel;
   }
 
   /// IR optimization level: from 0 to 3.
-  void setOptLevel(unsigned NewOptLevel) {
-    OptLevel = (NewOptLevel > 3) ? 3 : NewOptLevel;
-  }
+  void setOptLevel(OptimizationLevel NewOptLevel) { OptLevel = NewOptLevel; }
 
   /// Enable or disable the new pass manager.
   void setUseNewPM(unsigned Enabled) { UseNewPM = Enabled; }
 
   /// Enable or disable debug output for the new pass manager.
   void setDebugPassManager(unsigned Enabled) { DebugPassManager = Enabled; }
 
   /// Disable CodeGen, only run the stages till codegen and stop. The output
private:
   /// importing or optimization.
   bool CodeGenOnly = false;
 
   /// Flag to indicate that the optimizer should not assume builtins are present
   /// on the target.
   bool Freestanding = false;
 
   /// IR Optimization Level [0-3].
-  unsigned OptLevel = 3;
+  OptimizationLevel OptLevel = OptimizationLevel::O3;
 
   /// Flag to indicate whether the new pass manager should be used for IR
   /// optimizations.
   bool UseNewPM = LLVM_ENABLE_NEW_PASS_MANAGER;
 
   /// Flag to indicate whether debug output should be enabled for the new pass
   /// manager.
   bool DebugPassManager = false;
 };
 }
 #endif

llvm/include/llvm/Passes/OptimizationLevel.h

 /// This header enumerates the LLVM-provided high-level optimization levels.
 /// Each level has a specific goal and rationale.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_PASSES_OPTIMIZATIONLEVEL_H
 #define LLVM_PASSES_OPTIMIZATIONLEVEL_H
 
+#include "llvm/ADT/Optional.h"
 #include <assert.h>
 
 namespace llvm {
 
 class OptimizationLevel final {
   unsigned SpeedLevel = 2;
   unsigned SizeLevel = 0;
   OptimizationLevel(unsigned SpeedLevel, unsigned SizeLevel)
       : SpeedLevel(SpeedLevel), SizeLevel(SizeLevel) {
     // Check that only valid combinations are passed.
     assert(SpeedLevel <= 3 &&
            "Optimization level for speed should be 0, 1, 2, or 3");
     assert(SizeLevel <= 2 &&
            "Optimization level for size should be 0, 1, or 2");
     assert((SizeLevel == 0 || SpeedLevel == 2) &&
            "Optimize for size should be encoded with speedup level == 2");
   }
 
 public:
   OptimizationLevel() = default;
+
+  static Optional<OptimizationLevel> forChar(char c) {
+    switch (c) {
+    case '0':
+      return O0;
+    case '1':
+      return O1;
+    case '2':
+      return O2;
+    case '3':
+      return O3;
+    case 's':
+      return Os;
+    case 'z':
+      return Oz;
+    default:
+      return Optional<OptimizationLevel>();
+    }
+  }
+
   /// Disable as many optimizations as possible. This doesn't completely
   /// disable the optimizer in all cases, for example always_inline functions
   /// can be required to be inlined for correctness.
   static const OptimizationLevel O0;
 
   /// Optimize quickly without destroying debuggability.
   ///
   /// This level is tuned to produce a result from the optimizer as quickly

llvm/lib/LTO/LTO.cpp

#endif
   else
     AddUnsigned(-1);
   if (Conf.CodeModel)
     AddUnsigned(*Conf.CodeModel);
   else
     AddUnsigned(-1);
   AddUnsigned(Conf.CGOptLevel);
   AddUnsigned(Conf.CGFileType);
-  AddUnsigned(Conf.OptLevel);
+  AddUnsigned(Conf.OptLevel.getSizeLevel());
+  AddUnsigned(Conf.OptLevel.getSpeedupLevel());
   AddUnsigned(Conf.UseNewPM);
   AddUnsigned(Conf.Freestanding);
   AddString(Conf.OptPipeline);
   AddString(Conf.AAPipeline);
   AddString(Conf.OverrideTriple);
   AddString(Conf.DefaultTriple);
   AddString(Conf.DwoDir);
 
Error LTO::run(AddStreamFn AddStream, FileCache Cache) {
 
   auto isPrevailing = [&](GlobalValue::GUID G) {
     auto It = GUIDPrevailingResolutions.find(G);
     if (It == GUIDPrevailingResolutions.end())
       return PrevailingType::Unknown;
     return It->second;
   };
   computeDeadSymbolsWithConstProp(ThinLTO.CombinedIndex, GUIDPreservedSymbols,
-                                  isPrevailing, Conf.OptLevel > 0);
+                                  isPrevailing,
+                                  Conf.OptLevel.getSpeedupLevel() > 0);
 
   // Setup output file to emit statistics.
   auto StatsFileOrErr = setupStatsFile(Conf.StatsFile);
   if (!StatsFileOrErr)
     return StatsFileOrErr.takeError();
   std::unique_ptr<ToolOutputFile> StatsFile = std::move(StatsFileOrErr.get());
 
   Error Result = runRegularLTO(AddStream);
Error LTO::runThinLTO(AddStreamFn AddStream, FileCache Cache,
 
   // Perform index-based WPD. This will return immediately if there are
   // no index entries in the typeIdMetadata map (e.g. if we are instead
   // performing IR-based WPD in hybrid regular/thin LTO mode).
   std::map<ValueInfo, std::vector<VTableSlotSummary>> LocalWPDTargetsMap;
   runWholeProgramDevirtOnIndex(ThinLTO.CombinedIndex, ExportedGUIDs,
                                LocalWPDTargetsMap);
 
-  if (Conf.OptLevel > 0)
+  if (Conf.OptLevel.getSpeedupLevel() > 0)
     ComputeCrossModuleImport(ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
                              ImportLists, ExportLists);
 
   // Figure out which symbols need to be internalized. This also needs to happen
   // at -O0 because summary-based DCE is implemented using internalization, and
   // we must apply DCE consistently with the full LTO module in order to avoid
   // undefined references during the final link.
   for (auto &Res : GlobalResolutions) {

llvm/lib/LTO/LTOBackend.cpp

createTargetMachine(const Config &Conf, const Target *TheTarget, Module &M) {
   std::unique_ptr<TargetMachine> TM(TheTarget->createTargetMachine(
       TheTriple, Conf.CPU, Features.getString(), Conf.Options, RelocModel,
       CodeModel, Conf.CGOptLevel));
   assert(TM && "Failed to create target machine");
   return TM;
 }
 
 static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
-                           unsigned OptLevel, bool IsThinLTO,
-                           ModuleSummaryIndex *ExportSummary,
+                           bool IsThinLTO, ModuleSummaryIndex *ExportSummary,
                            const ModuleSummaryIndex *ImportSummary) {
   Optional<PGOOptions> PGOOpt;
   if (!Conf.SampleProfile.empty())
     PGOOpt = PGOOptions(Conf.SampleProfile, "", Conf.ProfileRemapping,
                         PGOOptions::SampleUse, PGOOptions::NoCSAction, true);
   else if (Conf.RunCSIRInstr) {
     PGOOpt = PGOOptions("", Conf.CSIRProfile, Conf.ProfileRemapping,
                         PGOOptions::IRUse, PGOOptions::CSIRInstr,
static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
   PB.registerLoopAnalyses(LAM);
   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
 
   ModulePassManager MPM;
 
   if (!Conf.DisableVerify)
     MPM.addPass(VerifierPass());
 
-  OptimizationLevel OL;
-
-  switch (OptLevel) {
-  default:
-    llvm_unreachable("Invalid optimization level");
-  case 0:
-    OL = OptimizationLevel::O0;
-    break;
-  case 1:
-    OL = OptimizationLevel::O1;
-    break;
-  case 2:
-    OL = OptimizationLevel::O2;
-    break;
-  case 3:
-    OL = OptimizationLevel::O3;
-    break;
-  }
-
   // Parse a custom pipeline if asked to.
   if (!Conf.OptPipeline.empty()) {
     if (auto Err = PB.parsePassPipeline(MPM, Conf.OptPipeline)) {
       report_fatal_error(Twine("unable to parse pass pipeline description '") +
                          Conf.OptPipeline + "': " + toString(std::move(Err)));
     }
   } else if (IsThinLTO) {
-    MPM.addPass(PB.buildThinLTODefaultPipeline(OL, ImportSummary));
+    MPM.addPass(PB.buildThinLTODefaultPipeline(Conf.OptLevel, ImportSummary));
   } else {
-    MPM.addPass(PB.buildLTODefaultPipeline(OL, ExportSummary));
+    MPM.addPass(PB.buildLTODefaultPipeline(Conf.OptLevel, ExportSummary));
   }
 
   if (!Conf.DisableVerify)
     MPM.addPass(VerifierPass());
 
   MPM.run(Mod, MAM);
 }
 
static void runOldPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
   PMB.ExportSummary = ExportSummary;
   PMB.ImportSummary = ImportSummary;
   // Unconditionally verify input since it is not verified before this
   // point and has unknown origin.
   PMB.VerifyInput = true;
   PMB.VerifyOutput = !Conf.DisableVerify;
   PMB.LoopVectorize = true;
   PMB.SLPVectorize = true;
-  PMB.OptLevel = Conf.OptLevel;
+  PMB.OptLevel = Conf.OptLevel.getSpeedupLevel();
+  PMB.SizeLevel = Conf.OptLevel.getSizeLevel();
   PMB.PGOSampleUse = Conf.SampleProfile;
   PMB.EnablePGOCSInstrGen = Conf.RunCSIRInstr;
   if (!Conf.RunCSIRInstr && !Conf.CSIRProfile.empty()) {
     PMB.EnablePGOCSInstrUse = true;
     PMB.PGOInstrUse = Conf.CSIRProfile;
   }
   if (IsThinLTO)
     PMB.populateThinLTOPassManager(passes);
if (CmdArgs.empty())
           dbgs() << "Post-(Thin)LTO merge bitcode embedding was requested, but "
                     "command line arguments are not available");
     llvm::EmbedBitcodeInModule(Mod, llvm::MemoryBufferRef(),
                                /*EmbedBitcode*/ true, /*EmbedCmdline*/ true,
                                /*Cmdline*/ CmdArgs);
   }
   // FIXME: Plumb the combined index into the new pass manager.
   if (Conf.UseNewPM || !Conf.OptPipeline.empty()) {
-    runNewPMPasses(Conf, Mod, TM, Conf.OptLevel, IsThinLTO, ExportSummary,
-                   ImportSummary);
+    runNewPMPasses(Conf, Mod, TM, IsThinLTO, ExportSummary, ImportSummary);
   } else {
     runOldPMPasses(Conf, Mod, TM, IsThinLTO, ExportSummary, ImportSummary);
   }
   return !Conf.PostOptModuleHook || Conf.PostOptModuleHook(Task, Mod);
 }
 
 static void codegen(const Config &Conf, TargetMachine *TM,
                     AddStreamFn AddStream, unsigned Task, Module &Mod,

llvm/lib/LTO/LTOCodeGenerator.cpp

 #include "llvm/LTO/LTOBackend.h"
 #include "llvm/LTO/legacy/LTOModule.h"
 #include "llvm/LTO/legacy/UpdateCompilerUsed.h"
 #include "llvm/Linker/Linker.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/MC/TargetRegistry.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Remarks/HotnessThresholdParser.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
void LTOCodeGenerator::setDebugInfo(lto_debug_model Debug) {
 
   case LTO_DEBUG_MODEL_DWARF:
     EmitDwarfDebugInfo = true;
     return;
   }
   llvm_unreachable("Unknown debug format!");
 }
 
-void LTOCodeGenerator::setOptLevel(unsigned Level) {
+void LTOCodeGenerator::setOptLevel(OptimizationLevel Level) {
   Config.OptLevel = Level;
-  Config.PTO.LoopVectorization = Config.OptLevel > 1;
-  Config.PTO.SLPVectorization = Config.OptLevel > 1;
-  switch (Config.OptLevel) {
+  Config.PTO.LoopVectorization = Config.OptLevel.getSpeedupLevel() > 1;
+  Config.PTO.SLPVectorization = Config.OptLevel.getSpeedupLevel() > 1;
+  switch (Config.OptLevel.getSpeedupLevel()) {
   case 0:
     Config.CGOptLevel = CodeGenOpt::None;
     return;
   case 1:
     Config.CGOptLevel = CodeGenOpt::Less;
     return;
   case 2:
     Config.CGOptLevel = CodeGenOpt::Default;

llvm/lib/LTO/ThinLTOCodeGenerator.cpp

 #include "llvm/IR/PassTimingInfo.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/LTO/SummaryBasedOptimizations.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Object/IRObjectFile.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Passes/PassBuilder.h"
 #include "llvm/Passes/StandardInstrumentations.h"
 #include "llvm/Remarks/HotnessThresholdParser.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Path.h"
if (!Result) {
     });
     report_fatal_error("importFunctions failed");
   }
   // Verify again after cross-importing.
   verifyLoadedModule(TheModule);
 }
 
 static void optimizeModule(Module &TheModule, TargetMachine &TM,
-                           unsigned OptLevel, bool Freestanding,
+                           OptimizationLevel OptLevel, bool Freestanding,
                            ModuleSummaryIndex *Index) {
   // Populate the PassManager
   PassManagerBuilder PMB;
   PMB.LibraryInfo = new TargetLibraryInfoImpl(TM.getTargetTriple());
   if (Freestanding)
     PMB.LibraryInfo->disableAllFunctions();
   PMB.Inliner = createFunctionInliningPass();
   // FIXME: should get it from the bitcode?
-  PMB.OptLevel = OptLevel;
+  PMB.OptLevel = OptLevel.getSpeedupLevel();
+  PMB.SizeLevel = OptLevel.getSizeLevel();
   PMB.LoopVectorize = true;
   PMB.SLPVectorize = true;
   // Already did this in verifyLoadedModule().
   PMB.VerifyInput = false;
   PMB.VerifyOutput = false;
   PMB.ImportSummary = Index;
 
   legacy::PassManager PM;
 
   // Add the TTI (required to inform the vectorizer about register size for
   // instance)
   PM.add(createTargetTransformInfoWrapperPass(TM.getTargetIRAnalysis()));
 
   // Add optimizations
   PMB.populateThinLTOPassManager(PM);
 
   PM.run(TheModule);
 }
 
 static void optimizeModuleNewPM(Module &TheModule, TargetMachine &TM,
-                                unsigned OptLevel, bool Freestanding,
+                                OptimizationLevel OptLevel, bool Freestanding,
                                 bool DebugPassManager,
                                 ModuleSummaryIndex *Index) {
   Optional<PGOOptions> PGOOpt;
   LoopAnalysisManager LAM;
   FunctionAnalysisManager FAM;
   CGSCCAnalysisManager CGAM;
   ModuleAnalysisManager MAM;
 
static void optimizeModuleNewPM(Module &TheModule, TargetMachine &TM,
   PB.registerModuleAnalyses(MAM);
   PB.registerCGSCCAnalyses(CGAM);
   PB.registerFunctionAnalyses(FAM);
   PB.registerLoopAnalyses(LAM);
   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
 
   ModulePassManager MPM;
 
-  OptimizationLevel OL;
-
-  switch (OptLevel) {
-  default:
-    llvm_unreachable("Invalid optimization level");
-  case 0:
-    OL = OptimizationLevel::O0;
-    break;
-  case 1:
-    OL = OptimizationLevel::O1;
-    break;
-  case 2:
-    OL = OptimizationLevel::O2;
-    break;
-  case 3:
-    OL = OptimizationLevel::O3;
-    break;
-  }
-
-  MPM.addPass(PB.buildThinLTODefaultPipeline(OL, Index));
+  MPM.addPass(PB.buildThinLTODefaultPipeline(OptLevel, Index));
 
   MPM.run(TheModule, MAM);
 }
 
 static void
 addUsedSymbolToPreservedGUID(const lto::InputFile &File,
                              DenseSet<GlobalValue::GUID> &PreservedGUID) {
   for (const auto &Sym : File.symbols()) {
public:
   // Create a cache entry. This compute a unique hash for the Module considering
   // the current list of export/import, and offer an interface to query to
   // access the content in the cache.
   ModuleCacheEntry(
       StringRef CachePath, const ModuleSummaryIndex &Index, StringRef ModuleID,
       const FunctionImporter::ImportMapTy &ImportList,
       const FunctionImporter::ExportSetTy &ExportList,
       const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
-      const GVSummaryMapTy &DefinedGVSummaries, unsigned OptLevel,
+      const GVSummaryMapTy &DefinedGVSummaries, OptimizationLevel OptLevel,
       bool Freestanding, const TargetMachineBuilder &TMBuilder) {
     if (CachePath.empty())
       return;
 
     if (!Index.modulePaths().count(ModuleID))
       // The module does not have an entry, it can't have a hash at all
       return;
 

 ProcessThinLTOModule(Module &TheModule, ModuleSummaryIndex &Index,
                      StringMap<lto::InputFile *> &ModuleMap, TargetMachine &TM,
                      const FunctionImporter::ImportMapTy &ImportList,
                      const FunctionImporter::ExportSetTy &ExportList,
                      const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols,
                      const GVSummaryMapTy &DefinedGlobals,
                      const ThinLTOCodeGenerator::CachingOptions &CacheOptions,
                      bool DisableCodeGen, StringRef SaveTempsDir,
-                     bool Freestanding, unsigned OptLevel, unsigned count,
-                     bool UseNewPM, bool DebugPassManager) {
+                     bool Freestanding, OptimizationLevel OptLevel,
+                     unsigned count, bool UseNewPM, bool DebugPassManager) {
 
   // "Benchmark"-like optimization: single-source case
   bool SingleModule = (ModuleMap.size() == 1);
 
   // When linking an ELF shared object, dso_local should be dropped. We
   // conservatively do this for -fpic.
   bool ClearDSOLocalOnDeclarations =
       TM.getTargetTriple().isOSBinFormatELF() &&

llvm/test/tools/llvm-lto2/X86/opt-levels.ll

+; RUN: opt -module-summary %s -o %t1.bc
+
+; RUN: llvm-lto2 run %t1.bc -o %t5.o -O3 -r %t1.bc,c,plx -r %t1.bc,d,plx -r %t1.bc,f,plx -r %t1.bc,foo,plx \
+; RUN:  -use-new-pm -save-temps
+; RUN: llvm-dis %t5.o.1.4.opt.bc -o - | FileCheck %s --check-prefixes=O3,CHECK
+
+; RUN: llvm-lto2 run %t1.bc -o %t5.o -Os -r %t1.bc,c,plx -r %t1.bc,d,plx -r %t1.bc,f,plx -r %t1.bc,foo,plx \
+; RUN:  -use-new-pm -save-temps
+; RUN: llvm-dis %t5.o.1.4.opt.bc -o - | FileCheck %s --check-prefixes=OS,CHECK
+
+; RUN: llvm-lto2 run %t1.bc -o %t5.o -Oz -r %t1.bc,c,plx -r %t1.bc,d,plx -r %t1.bc,f,plx -r %t1.bc,foo,plx \
+; RUN:  -use-new-pm -save-temps
+; RUN: llvm-dis %t5.o.1.4.opt.bc -o - | FileCheck %s --check-prefixes=OZ,CHECK
+
+; CHECK-LABEL: define {{.*}}@foo
+; O3-NOT: call void @c
+; O3-NOT: call void @d
+; OS-NOT: call void @c
+; OS: call void @d
+; OZ: call void @c
+; OZ: call void @d
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+declare void @f()
+
+define void @c() "function-inline-cost"="10" {
+  call void @f()
+  ret void
+}
+
+define void @d() "function-inline-cost"="100" {
+  call void @f()
+  ret void
+}
+
+define void @foo(i32* %a) {
+  call void @c()
+  call void @d()
+  ret void
+}
 No newline at end of file

llvm/test/tools/llvm-lto2/X86/slp-vectorize-pm.ll

 ; RUN: llvm-lto2 run %t1.bc -o %t4.o -O2 -r %t1.bc,foo,plx -debug-pass-manager \
 ; RUN:  -use-new-pm -save-temps 2>&1 | FileCheck %s --check-prefix=CHECK-O2-SLP
 ; RUN: llvm-dis %t4.o.1.4.opt.bc -o - | FileCheck %s --check-prefix=CHECK-O2-LPV
 
 ; RUN: llvm-lto2 run %t1.bc -o %t5.o -O3 -r %t1.bc,foo,plx -debug-pass-manager \
 ; RUN:  -use-new-pm -save-temps 2>&1 | FileCheck %s --check-prefix=CHECK-O3-SLP
 ; RUN: llvm-dis %t5.o.1.4.opt.bc -o - | FileCheck %s --check-prefix=CHECK-O3-LPV
 
+; RUN: llvm-lto2 run %t1.bc -o %t5.o -Os -r %t1.bc,foo,plx -debug-pass-manager \
+; RUN:  -use-new-pm -save-temps 2>&1 | FileCheck %s --check-prefix=CHECK-O3-SLP
+; RUN: llvm-dis %t5.o.1.4.opt.bc -o - | FileCheck %s --check-prefix=CHECK-O3-LPV
+
+; RUN: llvm-lto2 run %t1.bc -o %t5.o -Oz -r %t1.bc,foo,plx -debug-pass-manager \
+; RUN:  -use-new-pm -save-temps 2>&1 | FileCheck %s --check-prefix=CHECK-O3-SLP
+; RUN: llvm-dis %t5.o.1.4.opt.bc -o - | FileCheck %s --check-prefix=CHECK-O3-LPV
+
 ; CHECK-O0-SLP-NOT: Running pass: SLPVectorizerPass
 ; CHECK-O1-SLP-NOT: Running pass: SLPVectorizerPass
 ; CHECK-O2-SLP: Running pass: SLPVectorizerPass
 ; CHECK-O3-SLP: Running pass: SLPVectorizerPass
 ; CHECK-O0-LPV-NOT: = !{!"llvm.loop.isvectorized", i32 1}
 ; CHECK-O1-LPV-NOT: = !{!"llvm.loop.isvectorized", i32 1}
 ; CHECK-O2-LPV: = !{!"llvm.loop.isvectorized", i32 1}
 ; CHECK-O3-LPV: = !{!"llvm.loop.isvectorized", i32 1}

llvm/test/tools/lto/opt-level.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: %ld64 -lto_library %llvmshlibdir/libLTO.dylib -arch x86_64 -dylib -mllvm -O0 -o %t.dylib %t.o -lSystem
 ; RUN: llvm-nm --no-llvm-bc %t.dylib | FileCheck --check-prefix=CHECK-O0 %s
 ; RUN: %ld64 -lto_library %llvmshlibdir/libLTO.dylib -arch x86_64 -dylib -mllvm -O2 -o %t.dylib %t.o -lSystem
 ; RUN: llvm-nm --no-llvm-bc %t.dylib | FileCheck --check-prefix=CHECK-O2 %s
+; RUN: %ld64 -lto_library %llvmshlibdir/libLTO.dylib -arch x86_64 -dylib -mllvm -Os -o %t.dylib %t.o -lSystem
+; RUN: llvm-nm --no-llvm-bc %t.dylib | FileCheck --check-prefix=CHECK-O2 %s
+; RUN: %ld64 -lto_library %llvmshlibdir/libLTO.dylib -arch x86_64 -dylib -mllvm -Oz -o %t.dylib %t.o -lSystem
+; RUN: llvm-nm --no-llvm-bc %t.dylib | FileCheck --check-prefix=CHECK-O2 %s
 
 target triple = "x86_64-apple-macosx10.8.0"
 
 ; CHECK-O0: t _f1
 ; CHECK-O2-NOT: _f1
 define internal void @f1() {
   ret void
 }
 
 ; CHECK-O0: T _f2
 ; CHECK-O2: T _f2
 define void @f2() {
   call void @f1()
   ret void
 }

llvm/tools/llvm-lto/llvm-lto.cpp

 using namespace llvm;
 
 static codegen::RegisterCodeGenFlags CGF;
 
 static cl::OptionCategory LTOCategory("LTO Options");
 
 static cl::opt<char>
     OptLevel("O",
-             cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
+             cl::desc("Optimization level. [-O0, -O1, -O2, -O3, -Os, or -Oz] "
                       "(default = '-O2')"),
              cl::Prefix, cl::ZeroOrMore, cl::init('2'), cl::cat(LTOCategory));
 
 static cl::opt<bool>
     IndexStats("thinlto-index-stats",
                cl::desc("Print statistic for the index in every input files"),
                cl::init(false), cl::cat(LTOCategory));
 

 
 } // end namespace thinlto
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
   cl::HideUnrelatedOptions({&LTOCategory, &getColorCategory()});
   cl::ParseCommandLineOptions(argc, argv, "llvm LTO linker\n");
 
-  if (OptLevel < '0' || OptLevel > '3')
-    error("optimization level must be between 0 and 3");
-
   // Initialize the configured targets.
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
   InitializeAllAsmParsers();
 
   // set up the TargetOptions for the machine
   TargetOptions Options = codegen::InitTargetOptionsFromCodeGenFlags(Triple());
int main(int argc, char **argv) {
 
   // Add all the dso symbols to the table of symbols to expose.
   for (unsigned i = 0; i < KeptDSOSyms.size(); ++i)
     CodeGen.addMustPreserveSymbol(KeptDSOSyms[i]);
 
   // Set cpu and attrs strings for the default target/subtarget.
   CodeGen.setCpu(codegen::getMCPU());
 
-  CodeGen.setOptLevel(OptLevel - '0');
+  Optional<OptimizationLevel> OL = OptimizationLevel::forChar(OptLevel);
+  if (!OL)
+    error("invalid optimization level: -O" + Twine(OptLevel));
+  CodeGen.setOptLevel(*OL);
+
   CodeGen.setAttrs(codegen::getMAttrs());
 
   CodeGen.setUseNewPM(UseNewPM);
 
   if (auto FT = codegen::getExplicitFileType())
     CodeGen.setFileType(FT.getValue());
 
   if (!OutputFilename.empty()) {

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

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/LTO/LTO.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Passes/PassPlugin.h"
 #include "llvm/Remarks/HotnessThresholdParser.h"
 #include "llvm/Support/Caching.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/PluginLoader.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/Threading.h"
 
 using namespace llvm;
 using namespace lto;
 
 static codegen::RegisterCodeGenFlags CGF;
 
 static cl::opt<char>
-    OptLevel("O", cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
-                           "(default = '-O2')"),
+    OptLevel("O",
+             cl::desc("Optimization level. [-O0, -O1, -O2, -O3, -Os, or -Oz] "
              cl::Prefix, cl::ZeroOrMore, cl::init('2'));
 
 static cl::opt<char> CGOptLevel(
     "cg-opt-level",
     cl::desc("Codegen optimization level (0, 1, 2 or 3, default = '2')"),
     cl::init('2'));
 
 static cl::list<std::string> InputFilenames(cl::Positional, cl::OneOrMore,
static int run(int argc, char **argv) {
   Conf.SampleProfile = SamplePGOFile;
   Conf.CSIRProfile = CSPGOFile;
   Conf.RunCSIRInstr = RunCSIRInstr;
 
   // Run a custom pipeline, if asked for.
   Conf.OptPipeline = OptPipeline;
   Conf.AAPipeline = AAPipeline;
 
-  Conf.OptLevel = OptLevel - '0';
+  if (auto OL = OptimizationLevel::forChar(OptLevel)) {
+    Conf.OptLevel = *OL;
+  } else {
+    llvm::errs() << "invalid -O level: -O" << OptLevel << "\n";
+    return 1;
+  }
   Conf.UseNewPM = UseNewPM;
   Conf.Freestanding = EnableFreestanding;
   for (auto &PluginFN : PassPlugins)
     Conf.PassPlugins.push_back(PluginFN);
   switch (CGOptLevel) {
   case '0':
     Conf.CGOptLevel = CodeGenOpt::None;
     break;
static int run(int argc, char **argv) {
   }
 
   if (auto FT = codegen::getExplicitFileType())
     Conf.CGFileType = FT.getValue();
 
   Conf.OverrideTriple = OverrideTriple;
   Conf.DefaultTriple = DefaultTriple;
   Conf.StatsFile = StatsFile;
-  Conf.PTO.LoopVectorization = Conf.OptLevel > 1;
-  Conf.PTO.SLPVectorization = Conf.OptLevel > 1;
+  Conf.PTO.LoopVectorization = Conf.OptLevel.getSpeedupLevel() > 1;
+  Conf.PTO.SLPVectorization = Conf.OptLevel.getSpeedupLevel() > 1;
 
   ThinBackend Backend;
   if (ThinLTODistributedIndexes)
     Backend = createWriteIndexesThinBackend(/* OldPrefix */ "",
                                             /* NewPrefix */ "",
                                             /* ShouldEmitImportsFiles */ true,
                                             /* LinkedObjectsFile */ nullptr,
                                             /* OnWrite */ {});

llvm/tools/lto/lto.cpp

 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/LTO/legacy/LTOCodeGenerator.h"
 #include "llvm/LTO/legacy/LTOModule.h"
 #include "llvm/LTO/legacy/ThinLTOCodeGenerator.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 static codegen::RegisterCodeGenFlags CGF;
 
 // extra command-line flags needed for LTOCodeGenerator
 static cl::opt<char>
     OptLevel("O",
-         cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
+             cl::desc("Optimization level. [-O0, -O1, -O2, -O3, -Os, or -Oz] "
                       "(default = '-O2')"),
-         cl::Prefix,
-         cl::ZeroOrMore,
-         cl::init('2'));
+             cl::Prefix, cl::ZeroOrMore, cl::init('2'));
 
 static cl::opt<bool> EnableFreestanding(
     "lto-freestanding", cl::init(false),
     cl::desc("Enable Freestanding (disable builtins / TLI) during LTO"));
 
 #ifdef NDEBUG
 static bool VerifyByDefault = false;
 #else

 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ThinLTOCodeGenerator, thinlto_code_gen_t)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LTOModule, lto_module_t)
 
 // Convert the subtarget features into a string to pass to LTOCodeGenerator.
 static void lto_add_attrs(lto_code_gen_t cg) {
   LTOCodeGenerator *CG = unwrap(cg);
   CG->setAttrs(codegen::getMAttrs());
 
-  if (OptLevel < '0' || OptLevel > '3')
-    report_fatal_error("Optimization level must be between 0 and 3");
-  CG->setOptLevel(OptLevel - '0');
+  Optional<OptimizationLevel> OL = OptimizationLevel::forChar(OptLevel);
+  if (!OL)
+    report_fatal_error("invalid optimization level: -O" + Twine(OptLevel));
+  CG->setOptLevel(*OL);
   CG->setFreestanding(EnableFreestanding);
   CG->setDisableVerify(DisableVerify);
 }
 
 extern const char* lto_get_version() {
   return LTOCodeGenerator::getVersionString();
 }
 

 thinlto_code_gen_t thinlto_create_codegen(void) {
   lto_initialize();
   ThinLTOCodeGenerator *CodeGen = new ThinLTOCodeGenerator();
   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':
+    Optional<OptimizationLevel> OL = OptimizationLevel::forChar(OptLevel);
+    if (!OL)
+      report_fatal_error("Invalid optimization level: " + Twine(OptLevel));
+    CodeGen->setOptLevel(*OL);
+    switch (OL->getSpeedupLevel()) {
+    case 0:
       CodeGen->setCodeGenOptLevel(CodeGenOpt::None);
       break;
-    case '1':
+    case 1:
       CodeGen->setCodeGenOptLevel(CodeGenOpt::Less);
       break;
-    case '2':
+    case 2:
       CodeGen->setCodeGenOptLevel(CodeGenOpt::Default);
       break;
-    case '3':
+    case 3:
       CodeGen->setCodeGenOptLevel(CodeGenOpt::Aggressive);
       break;
     }
   }
   return wrap(CodeGen);
 }
 
 void thinlto_codegen_dispose(thinlto_code_gen_t cg) { delete unwrap(cg); }

llvm/utils/gn/secondary/lld/Common/BUILD.gn

static_library("Common") {
   ]
   deps = [
     ":write_vcsversion",
     "//llvm/lib/CodeGen",
     "//llvm/lib/Demangle",
     "//llvm/lib/IR",
     "//llvm/lib/MC",
     "//llvm/lib/Option",
+    "//llvm/lib/Passes",
     "//llvm/lib/Support",
     "//llvm/lib/Target",
   ]
   sources = [
     "Args.cpp",
     "DWARF.cpp",
     "ErrorHandler.cpp",
     "Filesystem.cpp",
     "Memory.cpp",
     "Reproduce.cpp",
     "Strings.cpp",
     "TargetOptionsCommandFlags.cpp",
     "Timer.cpp",
     "Version.cpp",
   ]
 }