[WIP] Add IR function attributes to represent codegen optimization level

[mcrosier]

Summary

This patch is being posted along with the following RFC:

[RFC] Adding function attributes to represent codegen optimization level

This patch is a WIP and not necessarily something that is ready for review. As such, please direct your comments to the RFC rather than here.

Chad

[efriedma]

lib/IR/Module.cpp

91

This doesn't make any sense. If it's a per-function attribute, we should be computing it per function. The maximum level set on any function doesn't have any useful meaning.

[mcrosier]

lib/IR/Module.cpp

91

The goal here is to approximate the codegen optimization level during LTO based on function level attributes. Per the RFC, after r324557 the codegen optimization level for LTO is always CodeGenOpt::Default and is not configurable AFAICT. However, the codegen optimization level has implications on how the codegen pipelines works (e.g., fast-isel vs selection dag, greedy vs. fast register allocator), which is at least one reason to try an approximate the codegen opt level (see the use of this function in lib/LTO/LTO.cpp).

On why I pick the max.. my thought is that if we're compiling with LTO the user is probably willing to aggressively optimize, so the heuristic chooses the highest optimization level...

[efriedma]

lib/IR/Module.cpp

91

Whether we use fast-isel vs. selectiondag or greedy vs. fast regalloc are choices we could, and should, make at a per-function level. Actually, we already choose between fast-isel vs. selectiondagisel on a per-function level, depending on whether optnone is specified.

I think the right design here looks very different: "optaggressive" should just be a hint that we want a different codesize/efficiency tradeoff, like "optsize". Then we should fix optimizations to use that hint instead of the global OptLevel. (I only count four places in lib/CodeGen/ and lib/Target/AArch64/ which actually distinguish between -O2 and -O3, so this shouldn't be difficult to implement.)

[mcrosier]

lib/IR/Module.cpp

91

I completely agree that part of the fix is to have the optimizers use the function attributes as hints, rather than use the TargetPass optimization level. However, this doesn't address the fact that the compilation pipeline is (currently) based on some global notion of the optimization level (e.g., several passes, including RA, are either excluded or behave differently because of CodeGenOpt::None and for AArch64 the SeparateConstOffsetFromGEPPass is only run with CodeGenOpt::Aggressive). This is what this bit of logic is trying to accomplish (albeit in a rather displeasing way). In the long term, that might not be how the codegen pass pipeline works, but TBH I'm not interested in pursuing that fix...

Perhaps just adding the function attributes and then modifying the function-level passes to use the function attributes rather than the TargetPass optimization level is a reasonable first step. This does at least fix the particular case I care about (i.e., enabling tail duplication during block placement).

[efriedma]

lib/IR/Module.cpp

91

Of course you don't have to fix everything at once; I understand some bits are sort of complicated. I just want to make sure we're moving in the right direction; we should be deprecating CodeGenOpt::Level, not building more infrastructure around it.

include/llvm/Bitcode/LLVMBitCodes.h

enum AttributeKindCodes {
   ATTR_KIND_INACCESSIBLEMEM_OR_ARGMEMONLY = 50,
   ATTR_KIND_ALLOC_SIZE = 51,
   ATTR_KIND_WRITEONLY = 52,
   ATTR_KIND_SPECULATABLE = 53,
   ATTR_KIND_STRICT_FP = 54,
   ATTR_KIND_SANITIZE_HWADDRESS = 55,
   ATTR_KIND_NOCF_CHECK = 56,
   ATTR_KIND_OPT_FOR_FUZZING = 57,
+  ATTR_KIND_OPTIMIZE_LESS = 58,
+  ATTR_KIND_OPTIMIZE_DEFAULT = 59,
+  ATTR_KIND_OPTIMIZE_AGGRESSIVE = 60,
 };
 
 enum ComdatSelectionKindCodes {
   COMDAT_SELECTION_KIND_ANY = 1,
   COMDAT_SELECTION_KIND_EXACT_MATCH = 2,
   COMDAT_SELECTION_KIND_LARGEST = 3,
   COMDAT_SELECTION_KIND_NO_DUPLICATES = 4,
   COMDAT_SELECTION_KIND_SAME_SIZE = 5,

include/llvm/IR/Attributes.td

 def NoCfCheck : EnumAttr<"nocf_check">;
 
 /// Function doesn't unwind stack.
 def NoUnwind : EnumAttr<"nounwind">;
 
 /// Select optimizations for best fuzzing signal.
 def OptForFuzzing : EnumAttr<"optforfuzzing">;
 
-/// opt_size.
+/// Function optimized for size.
 def OptimizeForSize : EnumAttr<"optsize">;
 
 /// Function must not be optimized.
 def OptimizeNone : EnumAttr<"optnone">;
 
+/// Function optimized at -O1.
+def OptimizeLess : EnumAttr<"optless">;
+
+/// Function optimized at -O2.
+def OptimizeDefault : EnumAttr<"optdefault">;
+
+/// Function optimized at -O3.
+def OptimizeAggressive : EnumAttr<"optaggr">;
+
 /// Function does not access memory.
 def ReadNone : EnumAttr<"readnone">;
 
 /// Function only reads from memory.
 def ReadOnly : EnumAttr<"readonly">;
 
 /// Return value is always equal to this argument.
 def Returned : EnumAttr<"returned">;

include/llvm/IR/Function.h

 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GlobalObject.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/OperandTraits.h"
 #include "llvm/IR/SymbolTableListTraits.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Compiler.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <string>
 
 namespace llvm {
public:
   /// Optimize this function for minimum size (-Oz).
   bool optForMinSize() const { return hasFnAttribute(Attribute::MinSize); }
 
   /// Optimize this function for size (-Os) or minimum size (-Oz).
   bool optForSize() const {
     return hasFnAttribute(Attribute::OptimizeForSize) || optForMinSize();
   }
 
+  CodeGenOpt::Level getCodeGenOptLevel() const {
+    if (hasFnAttribute(Attribute::OptimizeNone))
+      return CodeGenOpt::None;
+
+    if (hasFnAttribute(Attribute::OptimizeLess))
+      return CodeGenOpt::Less;
+
+    if (hasFnAttribute(Attribute::OptimizeDefault))
+      return CodeGenOpt::Default;
+
+    if (hasFnAttribute(Attribute::OptimizeAggressive))
+      return CodeGenOpt::Aggressive;
+
+    return CodeGenOpt::Default;
+  }
+
   /// copyAttributesFrom - copy all additional attributes (those not needed to
   /// create a Function) from the Function Src to this one.
   void copyAttributesFrom(const Function *Src);
 
   /// deleteBody - This method deletes the body of the function, and converts
   /// the linkage to external.
   ///
   void deleteBody() {

include/llvm/IR/Module.h

/// @{
 
   /// Get the data layout for the module's target platform.
   const DataLayout &getDataLayout() const;
 
   /// Get the target triple which is a string describing the target host.
   /// @returns a string containing the target triple.
   const std::string &getTargetTriple() const { return TargetTriple; }
 
+  CodeGenOpt::Level getCodeGenOptLevel() const;
+
   /// Get the global data context.
   /// @returns LLVMContext - a container for LLVM's global information
   LLVMContext &getContext() const { return Context; }
 
   /// Get any module-scope inline assembly blocks.
   /// @returns a string containing the module-scope inline assembly blocks.
   const std::string &getModuleInlineAsm() const { return GlobalScopeAsm; }
 

lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(nonlazybind);
   KEYWORD(nonnull);
   KEYWORD(noredzone);
   KEYWORD(noreturn);
   KEYWORD(nocf_check);
   KEYWORD(nounwind);
   KEYWORD(optforfuzzing);
   KEYWORD(optnone);
+  KEYWORD(optless);
+  KEYWORD(optdefault);
+  KEYWORD(optaggr);
   KEYWORD(optsize);
   KEYWORD(readnone);
   KEYWORD(readonly);
   KEYWORD(returned);
   KEYWORD(returns_twice);
   KEYWORD(signext);
   KEYWORD(speculatable);
   KEYWORD(sret);

lib/AsmParser/LLParser.cpp

while (true) {
     case lltok::kw_noredzone: B.addAttribute(Attribute::NoRedZone); break;
     case lltok::kw_noreturn: B.addAttribute(Attribute::NoReturn); break;
     case lltok::kw_nocf_check: B.addAttribute(Attribute::NoCfCheck); break;
     case lltok::kw_norecurse: B.addAttribute(Attribute::NoRecurse); break;
     case lltok::kw_nounwind: B.addAttribute(Attribute::NoUnwind); break;
     case lltok::kw_optforfuzzing:
       B.addAttribute(Attribute::OptForFuzzing); break;
     case lltok::kw_optnone: B.addAttribute(Attribute::OptimizeNone); break;
+    case lltok::kw_optless:
+      B.addAttribute(Attribute::OptimizeLess);
+      break;
+    case lltok::kw_optdefault:
+      B.addAttribute(Attribute::OptimizeDefault);
+      break;
+    case lltok::kw_optaggr:
+      B.addAttribute(Attribute::OptimizeAggressive);
+      break;
     case lltok::kw_optsize: B.addAttribute(Attribute::OptimizeForSize); break;
     case lltok::kw_readnone: B.addAttribute(Attribute::ReadNone); break;
     case lltok::kw_readonly: B.addAttribute(Attribute::ReadOnly); break;
     case lltok::kw_returns_twice:
       B.addAttribute(Attribute::ReturnsTwice); break;
     case lltok::kw_speculatable: B.addAttribute(Attribute::Speculatable); break;
     case lltok::kw_ssp: B.addAttribute(Attribute::StackProtect); break;
     case lltok::kw_sspreq: B.addAttribute(Attribute::StackProtectReq); break;
while (true) {
     case lltok::kw_noinline:
     case lltok::kw_nonlazybind:
     case lltok::kw_noredzone:
     case lltok::kw_noreturn:
     case lltok::kw_nocf_check:
     case lltok::kw_nounwind:
     case lltok::kw_optforfuzzing:
     case lltok::kw_optnone:
+    case lltok::kw_optless:
+    case lltok::kw_optdefault:
+    case lltok::kw_optaggr:
     case lltok::kw_optsize:
     case lltok::kw_returns_twice:
     case lltok::kw_sanitize_address:
     case lltok::kw_sanitize_hwaddress:
     case lltok::kw_sanitize_memory:
     case lltok::kw_sanitize_thread:
     case lltok::kw_ssp:
     case lltok::kw_sspreq:
while (true) {
     case lltok::kw_noinline:
     case lltok::kw_nonlazybind:
     case lltok::kw_noredzone:
     case lltok::kw_noreturn:
     case lltok::kw_nocf_check:
     case lltok::kw_nounwind:
     case lltok::kw_optforfuzzing:
     case lltok::kw_optnone:
+    case lltok::kw_optless:
+    case lltok::kw_optdefault:
+    case lltok::kw_optaggr:
     case lltok::kw_optsize:
     case lltok::kw_returns_twice:
     case lltok::kw_sanitize_address:
     case lltok::kw_sanitize_hwaddress:
     case lltok::kw_sanitize_memory:
     case lltok::kw_sanitize_thread:
     case lltok::kw_ssp:
     case lltok::kw_sspreq:

lib/AsmParser/LLToken.h

enum Kind {
   kw_nonlazybind,
   kw_nonnull,
   kw_noredzone,
   kw_noreturn,
   kw_nocf_check,
   kw_nounwind,
   kw_optforfuzzing,
   kw_optnone,
+  kw_optless,
+  kw_optdefault,
+  kw_optaggr,
   kw_optsize,
   kw_readnone,
   kw_readonly,
   kw_returned,
   kw_returns_twice,
   kw_signext,
   kw_speculatable,
   kw_ssp,

lib/Bitcode/Reader/BitcodeReader.cpp

static uint64_t getRawAttributeMask(Attribute::AttrKind Val) {
   case Attribute::SwiftSelf:       return 1ULL << 51;
   case Attribute::SwiftError:      return 1ULL << 52;
   case Attribute::WriteOnly:       return 1ULL << 53;
   case Attribute::Speculatable:    return 1ULL << 54;
   case Attribute::StrictFP:        return 1ULL << 55;
   case Attribute::SanitizeHWAddress: return 1ULL << 56;
   case Attribute::NoCfCheck:       return 1ULL << 57;
   case Attribute::OptForFuzzing:   return 1ULL << 58;
+  case Attribute::OptimizeLess:
+    return 1ULL << 59;
+  case Attribute::OptimizeDefault:
+    return 1ULL << 60;
+  case Attribute::OptimizeAggressive:
+    return 1ULL << 61;
   case Attribute::Dereferenceable:
     llvm_unreachable("dereferenceable attribute not supported in raw format");
     break;
   case Attribute::DereferenceableOrNull:
     llvm_unreachable("dereferenceable_or_null attribute not supported in raw "
                      "format");
     break;
   case Attribute::ArgMemOnly:
static Attribute::AttrKind getAttrFromCode(uint64_t Code) {
   case bitc::ATTR_KIND_NO_UNWIND:
     return Attribute::NoUnwind;
   case bitc::ATTR_KIND_OPT_FOR_FUZZING:
     return Attribute::OptForFuzzing;
   case bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE:
     return Attribute::OptimizeForSize;
   case bitc::ATTR_KIND_OPTIMIZE_NONE:
     return Attribute::OptimizeNone;
+  case bitc::ATTR_KIND_OPTIMIZE_LESS:
+    return Attribute::OptimizeLess;
+  case bitc::ATTR_KIND_OPTIMIZE_DEFAULT:
+    return Attribute::OptimizeDefault;
+  case bitc::ATTR_KIND_OPTIMIZE_AGGRESSIVE:
+    return Attribute::OptimizeAggressive;
   case bitc::ATTR_KIND_READ_NONE:
     return Attribute::ReadNone;
   case bitc::ATTR_KIND_READ_ONLY:
     return Attribute::ReadOnly;
   case bitc::ATTR_KIND_RETURNED:
     return Attribute::Returned;
   case bitc::ATTR_KIND_RETURNS_TWICE:
     return Attribute::ReturnsTwice;

lib/Bitcode/Writer/BitcodeWriter.cpp

static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
   case Attribute::NoUnwind:
     return bitc::ATTR_KIND_NO_UNWIND;
   case Attribute::OptForFuzzing:
     return bitc::ATTR_KIND_OPT_FOR_FUZZING;
   case Attribute::OptimizeForSize:
     return bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE;
   case Attribute::OptimizeNone:
     return bitc::ATTR_KIND_OPTIMIZE_NONE;
+  case Attribute::OptimizeLess:
+    return bitc::ATTR_KIND_OPTIMIZE_LESS;
+  case Attribute::OptimizeDefault:
+    return bitc::ATTR_KIND_OPTIMIZE_DEFAULT;
+  case Attribute::OptimizeAggressive:
+    return bitc::ATTR_KIND_OPTIMIZE_AGGRESSIVE;
   case Attribute::ReadNone:
     return bitc::ATTR_KIND_READ_NONE;
   case Attribute::ReadOnly:
     return bitc::ATTR_KIND_READ_ONLY;
   case Attribute::Returned:
     return bitc::ATTR_KIND_RETURNED;
   case Attribute::ReturnsTwice:
     return bitc::ATTR_KIND_RETURNS_TWICE;

lib/IR/Attributes.cpp

std::string Attribute::getAsString(bool InAttrGrp) const {
   if (hasAttribute(Attribute::NoUnwind))
     return "nounwind";
   if (hasAttribute(Attribute::OptForFuzzing))
     return "optforfuzzing";
   if (hasAttribute(Attribute::OptimizeNone))
     return "optnone";
   if (hasAttribute(Attribute::OptimizeForSize))
     return "optsize";
+  if (hasAttribute(Attribute::OptimizeLess))
+    return "optless";
+  if (hasAttribute(Attribute::OptimizeDefault))
+    return "optdefault";
+  if (hasAttribute(Attribute::OptimizeAggressive))
+    return "optaggr";
   if (hasAttribute(Attribute::ReadNone))
     return "readnone";
   if (hasAttribute(Attribute::ReadOnly))
     return "readonly";
   if (hasAttribute(Attribute::WriteOnly))
     return "writeonly";
   if (hasAttribute(Attribute::Returned))
     return "returned";

lib/IR/Module.cpp

Module::~Module() {
   FunctionList.clear();
   AliasList.clear();
   IFuncList.clear();
   NamedMDList.clear();
   delete ValSymTab;
   delete static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab);
 }
 
+CodeGenOpt::Level Module::getCodeGenOptLevel() const {
+  if (FunctionList.empty())
+    return CodeGenOpt::Default;
+
+  CodeGenOpt::Level ModuleLevel = CodeGenOpt::None;
+  for (const Function &F : *this) {
+    CodeGenOpt::Level Level = F.getCodeGenOptLevel();
+    if (ModuleLevel < Level)
+      ModuleLevel = Level;
+
+    if (ModuleLevel == CodeGenOpt::Aggressive)
+      break;
+  }
+  return ModuleLevel;
+}
+
 std::unique_ptr<RandomNumberGenerator> Module::createRNG(const Pass* P) const {
   SmallString<32> Salt(P->getPassName());
 
   // This RNG is guaranteed to produce the same random stream only
   // when the Module ID and thus the input filename is the same. This
   // might be problematic if the input filename extension changes
   // (e.g. from .c to .bc or .ll).
   //

lib/IR/Verifier.cpp

static bool isFuncOnlyAttr(Attribute::AttrKind Kind) {
   case Attribute::SanitizeMemory:
   case Attribute::MinSize:
   case Attribute::NoDuplicate:
   case Attribute::Builtin:
   case Attribute::NoBuiltin:
   case Attribute::Cold:
   case Attribute::OptForFuzzing:
   case Attribute::OptimizeNone:
+  case Attribute::OptimizeLess:
+  case Attribute::OptimizeDefault:
+  case Attribute::OptimizeAggressive:
   case Attribute::JumpTable:
   case Attribute::Convergent:
   case Attribute::ArgMemOnly:
   case Attribute::NoRecurse:
   case Attribute::InaccessibleMemOnly:
   case Attribute::InaccessibleMemOrArgMemOnly:
   case Attribute::AllocSize:
   case Attribute::Speculatable:
if (Attrs.hasFnAttribute(Attribute::OptimizeNone)) {
     Assert(Attrs.hasFnAttribute(Attribute::NoInline),
            "Attribute 'optnone' requires 'noinline'!", V);
 
     Assert(!Attrs.hasFnAttribute(Attribute::OptimizeForSize),
            "Attributes 'optsize and optnone' are incompatible!", V);
 
     Assert(!Attrs.hasFnAttribute(Attribute::MinSize),
            "Attributes 'minsize and optnone' are incompatible!", V);
+
+    Assert(!Attrs.hasFnAttribute(Attribute::OptimizeLess),
+           "Attributes 'optless and optnone' are incompatible!", V);
+
+    Assert(!Attrs.hasFnAttribute(Attribute::OptimizeDefault),
+           "Attributes 'optdefault and optnone' are incompatible!", V);
+
+    Assert(!Attrs.hasFnAttribute(Attribute::OptimizeAggressive),
+           "Attributes 'optaggr and optnone' are incompatible!", V);
+  }
+
+  if (Attrs.hasFnAttribute(Attribute::OptimizeLess)) {
+    Assert(!Attrs.hasFnAttribute(Attribute::OptimizeNone),
+           "Attributes 'optnone and optless' are incompatible!", V);
+
+    Assert(!Attrs.hasFnAttribute(Attribute::OptimizeDefault),
+           "Attributes 'optdefault and optless' are incompatible!", V);
+
+    Assert(!Attrs.hasFnAttribute(Attribute::OptimizeAggressive),
+           "Attributes 'optaggr and optless' are incompatible!", V);
+  }
+
+  if (Attrs.hasFnAttribute(Attribute::OptimizeDefault)) {
+    Assert(!Attrs.hasFnAttribute(Attribute::OptimizeNone),
+           "Attributes 'optnone and optdefault' are incompatible!", V);
+
+    Assert(!Attrs.hasFnAttribute(Attribute::OptimizeLess),
+           "Attributes 'optless and optdefault' are incompatible!", V);
+
+    Assert(!Attrs.hasFnAttribute(Attribute::OptimizeAggressive),
+           "Attributes 'optaggr and optdefault' are incompatible!", V);
+  }
+
+  if (Attrs.hasFnAttribute(Attribute::OptimizeAggressive)) {
+    Assert(!Attrs.hasFnAttribute(Attribute::OptimizeNone),
+           "Attributes 'optnone and optaggr' are incompatible!", V);
+
+    Assert(!Attrs.hasFnAttribute(Attribute::OptimizeLess),
+           "Attributes 'optless and optaggr' are incompatible!", V);
+
+    Assert(!Attrs.hasFnAttribute(Attribute::OptimizeDefault),
+           "Attributes 'optdefault and optaggr' are incompatible!", V);
   }
 
+  //  Assert(Attrs.hasFnAttribute(Attribute::OptimizeNone) ||
+  //         Attrs.hasFnAttribute(Attribute::OptimizeLess) ||
+  //         Attrs.hasFnAttribute(Attribute::OptimizeDefault) ||
+  //         Attrs.hasFnAttribute(Attribute::OptimizeAggressive),
+  //         "Expected one of 'optnone, optless, optdefault or optaggr' on
+  //         function!", V);
+
   if (Attrs.hasFnAttribute(Attribute::JumpTable)) {
     const GlobalValue *GV = cast<GlobalValue>(V);
     Assert(GV->hasGlobalUnnamedAddr(),
            "Attribute 'jumptable' requires 'unnamed_addr'", V);
   }
 
   if (Attrs.hasFnAttribute(Attribute::AllocSize)) {
     std::pair<unsigned, Optional<unsigned>> Args =

lib/LTO/LTO.cpp

 using namespace object;
 
 #define DEBUG_TYPE "lto"
 
 static cl::opt<bool>
     DumpThinCGSCCs("dump-thin-cg-sccs", cl::init(false), cl::Hidden,
                    cl::desc("Dump the SCCs in the ThinLTO index's callgraph"));
 
+static cl::opt<char> CGOptLevel(
+    "cg-opt-level",
+    cl::desc("Codegen optimization level (0, 1, 2 or 3, default = '2')"),
+    cl::init('2'));
+
 // The values are (type identifier, summary) pairs.
 typedef DenseMap<
     GlobalValue::GUID,
     TinyPtrVector<const std::pair<const std::string, TypeIdSummary> *>>
     TypeIdSummariesByGuidTy;
 
 // Returns a unique hash for the Module considering the current list of
 // export/import and other global analysis results.

 }
 
 Error LTO::runRegularLTO(AddStreamFn AddStream) {
   for (auto &M : RegularLTO.ModsWithSummaries)
     if (Error Err = linkRegularLTO(std::move(M),
                                    /*LivenessFromIndex=*/true))
       return Err;
 
+  // Update the code generation optimization level based on function level
+  // attributes (or the command-line option, if specified).
+  if (CGOptLevel.getNumOccurrences() == 0)
+    Conf.CGOptLevel = RegularLTO.CombinedModule->getCodeGenOptLevel();
+  else {
+    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:
+      llvm::errs() << "invalid cg optimization level: " << CGOptLevel << '\n';
+    }
+  }
+
   // Make sure commons have the right size/alignment: we kept the largest from
   // all the prevailing when adding the inputs, and we apply it here.
   const DataLayout &DL = RegularLTO.CombinedModule->getDataLayout();
   for (auto &I : RegularLTO.Commons) {
     if (!I.second.Prevailing)
       // Don't do anything if no instance of this common was prevailing.
       continue;
     GlobalVariable *OldGV = RegularLTO.CombinedModule->getNamedGlobal(I.first);

lib/Transforms/Utils/CodeExtractor.cpp

if (Attr.isStringAttribute()) {
       case Attribute::NoImplicitFloat:
       case Attribute::NoInline:
       case Attribute::NonLazyBind:
       case Attribute::NoRedZone:
       case Attribute::NoUnwind:
       case Attribute::OptForFuzzing:
       case Attribute::OptimizeNone:
       case Attribute::OptimizeForSize:
+      case Attribute::OptimizeLess:
+      case Attribute::OptimizeDefault:
+      case Attribute::OptimizeAggressive:
       case Attribute::SafeStack:
       case Attribute::SanitizeAddress:
       case Attribute::SanitizeMemory:
       case Attribute::SanitizeThread:
       case Attribute::SanitizeHWAddress:
       case Attribute::StackProtect:
       case Attribute::StackProtectReq:
       case Attribute::StackProtectStrong:

tools/llvm-lto2/llvm-lto2.cpp

 using namespace llvm;
 using namespace lto;
 
 static cl::opt<char>
     OptLevel("O", cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
                            "(default = '-O2')"),
              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,
                                             cl::desc("<input bitcode files>"));
 
 static cl::opt<std::string> OutputFilename("o", cl::Required,
                                            cl::desc("Output filename"),
                                            cl::value_desc("filename"));
 
 static cl::opt<std::string> CacheDir("cache-dir", cl::desc("Cache Directory"),
static int run(int argc, char **argv) {
   Conf.SampleProfile = SamplePGOFile;
 
   // Run a custom pipeline, if asked for.
   Conf.OptPipeline = OptPipeline;
   Conf.AAPipeline = AAPipeline;
 
   Conf.OptLevel = OptLevel - '0';
   Conf.UseNewPM = UseNewPM;
-  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:
-    llvm::errs() << "invalid cg optimization level: " << CGOptLevel << '\n';
-    return 1;
-  }
 
   if (FileType.getNumOccurrences())
     Conf.CGFileType = FileType;
 
   Conf.OverrideTriple = OverrideTriple;
   Conf.DefaultTriple = DefaultTriple;
 
   ThinBackend Backend;