gold, libLTO: Add new flags to support bit set lowering.

[pcc]

Summary

Add lowerbitsets flag to gold plugin and libLTO, and add disable-opt flag to
gold plugin. These flags can be used by the compiler driver to enable/disable
various parts of the compilation pipeline in cases where they are not needed.

In particular, this helps reduce link time in cases where the bit set lowering
pass is needed for control flow integrity, but the rest of LTO is not needed.

[• rafael]

lib/Transforms/IPO/PassManagerBuilder.cpp

530

Should these still be enabled at -O0?

tools/gold/gold-plugin.cpp

98

DisableOpt.
LowerBitSets.

[pcc]

• Rename flags

lib/Transforms/IPO/PassManagerBuilder.cpp

530

The first one is essentially a compile-time optimization that happens to be run at link time due to technical restrictions. I guess we can't easily get the compile-time optimization level here.

The second one is basically dead stripping, which the linker would try to do anyway (but not necessarily very well depending on the object file format etc). I've also found that dead stripping is also less expensive here overall as we save time in the backend.

Because this flag + disable-opt is exposed to users in D8402, it seems reasonable to do these types of things here for the sake of efficiency (and, as a bonus, code size in some cases). We might want to change this set of passes later -- for example, if we parallelize the backend, DCE would be less useful here.

tools/gold/gold-plugin.cpp

98

Done

[pcc]

We went with r232769 instead.

include/llvm/LTO/LTOCodeGenerator.h

struct LTOCodeGenerator {
   // NOTE that it is up to the linker to remove the intermediate object file.
   //  Do not try to remove the object file in LTOCodeGenerator's destructor
   //  as we don't who (LTOCodeGenerator or the obj file) will last longer.
   bool compile_to_file(const char **name,
                        bool disableOpt,
                        bool disableInline,
                        bool disableGVNLoadPRE,
                        bool disableVectorization,
+                       bool lowerbitsets,
                        std::string &errMsg);
 
   // As with compile_to_file(), this function compiles the merged module into
   // single object file. Instead of returning the object-file-path to the caller
   // (linker), it brings the object to a buffer, and return the buffer to the
   // caller. This function should delete intermediate object file once its content
   // is brought to memory. Return NULL if the compilation was not successful.
   const void *compile(size_t *length,
                       bool disableOpt,
                       bool disableInline,
                       bool disableGVNLoadPRE,
                       bool disableVectorization,
+                      bool lowerbitsets,
                       std::string &errMsg);
 
   // Optimizes the merged module. Returns true on success.
   bool optimize(bool disableOpt,
                 bool disableInline,
                 bool disableGVNLoadPRE,
                 bool disableVectorization,
+                bool lowerbitsets,
                 std::string &errMsg);
 
   // Compiles the merged optimized module into a single object file. It brings
   // the object to a buffer, and returns the buffer to the caller. Return NULL
   // if the compilation was not successful.
   const void *compileOptimized(size_t *length, std::string &errMsg);
 
   void setDiagnosticHandler(lto_diagnostic_handler_t, void *);

include/llvm/Transforms/IPO/PassManagerBuilder.h

public:
   bool RerollLoops;
   bool LoadCombine;
   bool DisableGVNLoadPRE;
   bool VerifyInput;
   bool VerifyOutput;
   bool StripDebug;
   bool MergeFunctions;
 
+  /// Whether to lower bit sets at link time.
+  bool LowerBitSets;
+
 private:
   /// ExtensionList - This is list of all of the extensions that are registered.
   std::vector<std::pair<ExtensionPointTy, ExtensionFn> > Extensions;
 
 public:
   PassManagerBuilder();
   ~PassManagerBuilder();
   /// Adds an extension that will be used by all PassManagerBuilder instances.

lib/LTO/LTOCodeGenerator.cpp

 }
 
 
 bool LTOCodeGenerator::compile_to_file(const char **name,
                                        bool disableOpt,
                                        bool disableInline,
                                        bool disableGVNLoadPRE,
                                        bool disableVectorization,
+                                       bool lowerbitsets,
                                        std::string &errMsg) {
   if (!optimize(disableOpt, disableInline, disableGVNLoadPRE,
-                disableVectorization, errMsg))
+                disableVectorization, lowerbitsets, errMsg))
     return false;
 
   return compileOptimizedToFile(name, errMsg);
 }
 
 const void* LTOCodeGenerator::compile(size_t *length,
                                       bool disableOpt,
                                       bool disableInline,
                                       bool disableGVNLoadPRE,
                                       bool disableVectorization,
+                                      bool lowerbitsets,
                                       std::string &errMsg) {
   if (!optimize(disableOpt, disableInline, disableGVNLoadPRE,
-                disableVectorization, errMsg))
+                disableVectorization, lowerbitsets, errMsg))
     return nullptr;
 
   return compileOptimized(length, errMsg);
 }
 
 bool LTOCodeGenerator::determineTarget(std::string &errMsg) {
   if (TargetMach)
     return true;
void LTOCodeGenerator::applyScopeRestrictions() {
   ScopeRestrictionsDone = true;
 }
 
 /// Optimize merged modules using various IPO passes
 bool LTOCodeGenerator::optimize(bool DisableOpt,
                                 bool DisableInline,
                                 bool DisableGVNLoadPRE,
                                 bool DisableVectorization,
+                                bool LowerBitSets,
                                 std::string &errMsg) {
   if (!this->determineTarget(errMsg))
     return false;
 
   Module *mergedModule = IRLinker.getModule();
 
   // Mark which symbols can not be internalized
   this->applyScopeRestrictions();
bool LTOCodeGenerator::optimize(bool DisableOpt,
   PMB.DisableGVNLoadPRE = DisableGVNLoadPRE;
   PMB.LoopVectorize = !DisableVectorization;
   PMB.SLPVectorize = !DisableVectorization;
   if (!DisableInline)
     PMB.Inliner = createFunctionInliningPass();
   PMB.LibraryInfo = new TargetLibraryInfoImpl(TargetTriple);
   if (DisableOpt)
     PMB.OptLevel = 0;
+  PMB.LowerBitSets = LowerBitSets;
   PMB.VerifyInput = true;
   PMB.VerifyOutput = true;
 
   PMB.populateLTOPassManager(passes);
 
   // Run our queue of passes all at once now, efficiently.
   passes.run(*mergedModule);
 

lib/Transforms/IPO/PassManagerBuilder.cpp

PassManagerBuilder::PassManagerBuilder() {
     LoopVectorize = RunLoopVectorization;
     RerollLoops = RunLoopRerolling;
     LoadCombine = RunLoadCombine;
     DisableGVNLoadPRE = false;
     VerifyInput = false;
     VerifyOutput = false;
     StripDebug = false;
     MergeFunctions = false;
+    LowerBitSets = false;
 }
 
 PassManagerBuilder::~PassManagerBuilder() {
   delete LibraryInfo;
   delete Inliner;
 }
 
 /// Set of global extensions, automatically added as part of the standard set.
if (LoadCombine)
     PM.add(createLoadCombinePass());
 
   // Cleanup and simplify the code after the scalar optimizations.
   PM.add(createInstructionCombiningPass());
   addExtensionsToPM(EP_Peephole, PM);
 
   PM.add(createJumpThreadingPass());
 
-  // Lower bitset metadata to bitsets.
-  PM.add(createLowerBitSetsPass());
-
   // Delete basic blocks, which optimization passes may have killed.
   PM.add(createCFGSimplificationPass());
 
   // Now that we have optimized the program, discard unreachable functions.
   PM.add(createGlobalDCEPass());
 
   // FIXME: this is profitable (for compiler time) to do at -O0 too, but
   // currently it damages debug info.
if (StripDebug)
     PM.add(createStripSymbolsPass(true));
 
   if (VerifyInput)
     PM.add(createDebugInfoVerifierPass());
 
   if (OptLevel != 0)
     addLTOOptimizationPasses(PM);
 
+  if (LowerBitSets) {
+    // Lower bitset metadata to bitsets.
+    PM.add(createLowerBitSetsPass());
+
+    // Clean up after the bit set lowering pass.
+    PM.add(createCFGSimplificationPass());
+
+    // Discard unused entities if we haven't already done so.
+    if (OptLevel == 0)
+      PM.add(createGlobalDCEPass());
+  }
+
   if (VerifyOutput) {
     PM.add(createVerifierPass());
     PM.add(createDebugInfoVerifierPass());
   }
 }
 
 inline PassManagerBuilder *unwrap(LLVMPassManagerBuilderRef P) {
     return reinterpret_cast<PassManagerBuilder*>(P);

test/tools/gold/disable-opt.ll

+; RUN: llvm-as -o %t.bc %s
+; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so -plugin-opt=save-temps \
+; RUN:    -plugin-opt=disable-opt -r -o %t.o %t.bc
+; RUN: llvm-dis < %t.o.opt.bc -o - | FileCheck %s
+
+; CHECK: define internal void @foo(
+define internal void @foo() {
+  ret void
+}
+
+define void @bar() {
+  call void @foo()
+  ret void
+}

test/tools/gold/lowerbitsets.ll

+; RUN: llvm-as -o %t.bc %s
+; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so -plugin-opt=save-temps \
+; RUN:    -plugin-opt=lowerbitsets -r -o %t.o %t.bc
+; RUN: llvm-dis < %t.o.opt.bc -o - | FileCheck %s
+
+@a = constant i32 1
+
+!0 = !{!"bitset1", i32* @a, i32 0}
+
+; CHECK-NOT: llvm.bitsets
+!llvm.bitsets = !{ !0 }

tools/gold/gold-plugin.cpp

enum OutputType {
     OT_SAVE_TEMPS
   };
   static bool generate_api_file = false;
   static OutputType TheOutputType = OT_NORMAL;
   static std::string obj_path;
   static std::string extra_library_path;
   static std::string triple;
   static std::string mcpu;
+  static bool DisableOpt = false;
+  static bool LowerBitSets = false;
   // Additional options to pass into the code generator.
   // Note: This array will contain all plugin options which are not claimed
   // as plugin exclusive to pass to the code generator.
   // For example, "generate-api-file" and "as"options are for the plugin
   // use only and will not be passed.
   static std::vector<const char *> extra;
 
   static void process_plugin_option(const char* opt_)
static void process_plugin_option(const char* opt_)
     } else if (opt.startswith("obj-path=")) {
       obj_path = opt.substr(strlen("obj-path="));
     } else if (opt == "emit-llvm") {
       TheOutputType = OT_BC_ONLY;
     } else if (opt == "save-temps") {
       TheOutputType = OT_SAVE_TEMPS;
     } else if (opt == "disable-output") {
       TheOutputType = OT_DISABLE;
+    } else if (opt == "disable-opt") {
+      DisableOpt = true;
+    } else if (opt == "lowerbitsets") {
+      LowerBitSets = true;
     } else {
       // Save this option to pass to the code generator.
       // ParseCommandLineOptions() expects argv[0] to be program name. Lazily
       // add that.
       if (extra.empty())
         extra.push_back("LLVMgold");
 
       extra.push_back(opt_);
static void runLTOPasses(Module &M, TargetMachine &TM) {
 
   PassManagerBuilder PMB;
   PMB.LibraryInfo = new TargetLibraryInfoImpl(Triple(TM.getTargetTriple()));
   PMB.Inliner = createFunctionInliningPass();
   PMB.VerifyInput = true;
   PMB.VerifyOutput = true;
   PMB.LoopVectorize = true;
   PMB.SLPVectorize = true;
+  if (options::DisableOpt)
+    PMB.OptLevel = 0;
+  PMB.LowerBitSets = options::LowerBitSets;
   PMB.populateLTOPassManager(passes);
   passes.run(M);
 }
 
 static void saveBCFile(StringRef Path, Module &M) {
   std::error_code EC;
   raw_fd_ostream OS(Path, EC, sys::fs::OpenFlags::F_None);
   if (EC)

tools/llvm-lto/llvm-lto.cpp

 DisableGVNLoadPRE("disable-gvn-loadpre", cl::init(false),
   cl::desc("Do not run the GVN load PRE pass"));
 
 static cl::opt<bool>
 DisableLTOVectorization("disable-lto-vectorization", cl::init(false),
   cl::desc("Do not run loop or slp vectorization during LTO"));
 
 static cl::opt<bool>
+LowerBitSets("lowerbitsets", cl::init(false),
+  cl::desc("Run the lowerbitsets pass"));
+
+static cl::opt<bool>
 UseDiagnosticHandler("use-diagnostic-handler", cl::init(false),
   cl::desc("Use a diagnostic handler to test the handler interface"));
 
 static cl::list<std::string>
 InputFilenames(cl::Positional, cl::OneOrMore,
   cl::desc("<input bitcode files>"));
 
 static cl::opt<std::string>
int main(int argc, char **argv) {
   if (!attrs.empty())
     CodeGen.setAttr(attrs.c_str());
 
   if (!OutputFilename.empty()) {
     size_t len = 0;
     std::string ErrorInfo;
     const void *Code =
         CodeGen.compile(&len, DisableOpt, DisableInline, DisableGVNLoadPRE,
-                        DisableLTOVectorization, ErrorInfo);
+                        DisableLTOVectorization, LowerBitSets, ErrorInfo);
     if (!Code) {
       errs() << argv[0]
              << ": error compiling the code: " << ErrorInfo << "\n";
       return 1;
     }
 
     std::error_code EC;
     raw_fd_ostream FileStream(OutputFilename, EC, sys::fs::F_None);
     if (EC) {
       errs() << argv[0] << ": error opening the file '" << OutputFilename
              << "': " << EC.message() << "\n";
       return 1;
     }
 
     FileStream.write(reinterpret_cast<const char *>(Code), len);
   } else {
     std::string ErrorInfo;
     const char *OutputName = nullptr;
     if (!CodeGen.compile_to_file(&OutputName, DisableOpt, DisableInline,
                                  DisableGVNLoadPRE, DisableLTOVectorization,
-                                 ErrorInfo)) {
+                                 LowerBitSets, ErrorInfo)) {
       errs() << argv[0]
              << ": error compiling the code: " << ErrorInfo
              << "\n";
       return 1;
     }
 
     outs() << "Wrote native object file '" << OutputName << "'\n";
   }
 
   return 0;
 }

tools/lto/lto.cpp

 static cl::opt<bool>
 DisableGVNLoadPRE("disable-gvn-loadpre", cl::init(false),
   cl::desc("Do not run the GVN load PRE pass"));
 
 static cl::opt<bool>
 DisableLTOVectorization("disable-lto-vectorization", cl::init(false),
   cl::desc("Do not run loop or slp vectorization during LTO"));
 
+static cl::opt<bool>
+LowerBitSets("lowerbitsets", cl::init(false),
+  cl::desc("Run the lowerbitsets pass"));
+
 // Holds most recent error string.
 // *** Not thread safe ***
 static std::string sLastErrorString;
 
 // Holds the initialization state of the LTO module.
 // *** Not thread safe ***
 static bool initialized = false;
 

 const void *lto_codegen_compile(lto_code_gen_t cg, size_t *length) {
   if (!parsedOptions) {
     unwrap(cg)->parseCodeGenDebugOptions();
     lto_add_attrs(cg);
     parsedOptions = true;
   }
   return unwrap(cg)->compile(length, DisableOpt, DisableInline,
                              DisableGVNLoadPRE, DisableLTOVectorization,
-                             sLastErrorString);
+                             LowerBitSets, sLastErrorString);
 }
 
 bool lto_codegen_optimize(lto_code_gen_t cg) {
   if (!parsedOptions) {
     unwrap(cg)->parseCodeGenDebugOptions();
     lto_add_attrs(cg);
     parsedOptions = true;
   }
   return !unwrap(cg)->optimize(DisableOpt, DisableInline,
                                DisableGVNLoadPRE, DisableLTOVectorization,
-                               sLastErrorString);
+                               LowerBitSets, sLastErrorString);
 }
 
 const void *lto_codegen_compile_optimized(lto_code_gen_t cg, size_t *length) {
   if (!parsedOptions) {
     unwrap(cg)->parseCodeGenDebugOptions();
     lto_add_attrs(cg);
     parsedOptions = true;
   }
   return unwrap(cg)->compileOptimized(length, sLastErrorString);
 }
 
 bool lto_codegen_compile_to_file(lto_code_gen_t cg, const char **name) {
   if (!parsedOptions) {
     unwrap(cg)->parseCodeGenDebugOptions();
     lto_add_attrs(cg);
     parsedOptions = true;
   }
   return !unwrap(cg)->compile_to_file(
       name, DisableOpt, DisableInline, DisableGVNLoadPRE,
-      DisableLTOVectorization, sLastErrorString);
+      DisableLTOVectorization, LowerBitSets, sLastErrorString);
 }
 
 void lto_codegen_debug_options(lto_code_gen_t cg, const char *opt) {
   unwrap(cg)->setCodeGenDebugOptions(opt);
 }
 
 unsigned int lto_api_version() { return LTO_API_VERSION; }