Support Os or Oz inside the LTO

[jinlin]

Summary

The changes are to support Os and Oz inside the LTO.

[fhahn]

Thanks for the patch.

I think this probably should be split up in 2 different changes:

1. Changes to the pipeline (llvm/lib/Transforms/IPO/PassManagerBuilder.cpp). Ideally those come with some data motivating the change and why there won't be regressions.
2. Changes to LTOCodeGenerator & co. They also need a test.

[MaskRay]

I don' think mapping 's' to 4 and 'z' to 5 is suitable. It is quite different. If you just want clang -fuse-ld=lld -Oz -flto{,=thin} to work, it already does after D79919

[jinlin]

In D95541#2718205, @MaskRay wrote:

I don' think mapping 's' to 4 and 'z' to 5 is suitable. It is quite different. If you just want clang -fuse-ld=lld -Oz -flto{,=thin} to work, it already does after D79919

First of all, the changes in D719919 does not pass the SizeLevel information to any optimizations including inlining.

Secondly, the changes in D79919 is not general. It does not work in MacOS.

llvm/include/llvm/LTO/Config.h

struct Config {
   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;
+  unsigned SizeLevel = 0;
   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/lib/LTO/LTOBackend.cpp

static void runOldPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
                            const ModuleSummaryIndex *ImportSummary) {
   legacy::PassManager passes;
   passes.add(createTargetTransformInfoWrapperPass(TM->getTargetIRAnalysis()));
 
   PassManagerBuilder PMB;
   PMB.LibraryInfo = new TargetLibraryInfoImpl(Triple(TM->getTargetTriple()));
   if (Conf.Freestanding)
     PMB.LibraryInfo->disableAllFunctions();
-  PMB.Inliner = createFunctionInliningPass();
+  PMB.Inliner = createFunctionInliningPass(Conf.OptLevel, Conf.SizeLevel, false);
   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;

llvm/lib/LTO/LTOCodeGenerator.cpp

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) {
+  if (Level > 3) {
+    Config.SizeLevel = Level - 3;
+    Level = 2;
+  }
   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:

llvm/tools/lto/lto.cpp

 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");
+  if (OptLevel == 's')
+    OptLevel = '4';
+  else if (OptLevel == 'z')
+    OptLevel = '5';
+  if (OptLevel < '0' || OptLevel > '5')
+    report_fatal_error("Optimization level must be between 0 and 3 or Os or Oz");
   CG->setOptLevel(OptLevel - '0');
   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");
+    if (OptLevel == 's')
+      OptLevel = '4';
+    else if (OptLevel == 'z')
+      OptLevel = '5';
+    if (OptLevel < '0' || OptLevel > '5')
+      report_fatal_error("Optimization level must be between 0 and 3 or Os or Oz");
     CodeGen->setOptLevel(OptLevel - '0');
     switch (OptLevel) {
     case '0':
       CodeGen->setCodeGenOptLevel(CodeGenOpt::None);
       break;
     case '1':
       CodeGen->setCodeGenOptLevel(CodeGenOpt::Less);
       break;