[llvm-extract] Add -keep-const-init commandline option

[aqjune]

Summary

This adds -keep-const-init option to llvm-extract which preserves initializers of
used global constants.

For example:

$ cat a.ll
@g = constant i32 0
define i32 @f() {
  %v = load i32, i32* @g
  ret i32 %v
}

$ llvm-extract --func=f a.ll -S -o -
@g = external constant i32
define i32 @f() { .. }

$ llvm-extract --func=f a.ll -keep-const-init -S -o -
@g = constant i32 0
define i32 @f() { .. }

This option is useful in checking whether a function that uses a constant global is optimized correctly.

[MaskRay]

A typo in the summary:

define void @f() {     ;;;;;; void -> i32
  %v = load i32, i32* @g
  ret i32 %v
}

How about -keep-constinit -> -keep-const-init?

[MaskRay]

llvm/test/tools/llvm-extract/keep-constinit.ll

4

Add a llvm-extract -func foo -S < %s test that @cv is otherwise changed to a declaration.

[aqjune]

• Use -keep-const-init
• Update test

llvm/docs/CommandGuide/llvm-extract.rst

  specified multiple times to extract multiple global variables at once.
 
 **--rglob** *glob-regular-expr*
 
  Extract the global variable(s) matching *global-regular-expr* from the LLVM
  bitcode.  All global variables matching the regular expression will be
  extracted.  May be specified multiple times.
 
+**--keep-const-init**
+
+ Preserve the values of constant globals.
+
 **-help**
 
  Print a summary of command line options.
 
 **-o** *filename*
 
  Specify the output filename.  If filename is "-" (the default), then
  :program:`llvm-extract` sends its output to standard output.

llvm/include/llvm/Transforms/IPO.h

 /// This transform is designed to eliminate available external globals
 /// (functions or global variables)
 ///
 ModulePass *createEliminateAvailableExternallyPass();
 
 //===----------------------------------------------------------------------===//
 /// createGVExtractionPass - If deleteFn is true, this pass deletes
 /// the specified global values. Otherwise, it deletes as much of the module as
-/// possible, except for the global values specified.
+/// possible, except for the global values specified. If keepConstInit is true,
+/// the initializers of global constants are not deleted even if they are
+/// unused.
 ///
 ModulePass *createGVExtractionPass(std::vector<GlobalValue*>& GVs, bool
-                                   deleteFn = false);
+                                  deleteFn = false, bool keepConstInit = false);
 
 //===----------------------------------------------------------------------===//
 /// This pass performs iterative function importing from other modules.
 Pass *createFunctionImportPass();
 
 //===----------------------------------------------------------------------===//
 /// createFunctionInliningPass - Return a new pass object that uses a heuristic
 /// to inline direct function calls to small functions.

llvm/lib/Transforms/IPO/ExtractGV.cpp

static void makeVisible(GlobalValue &GV, bool Delete) {
   }
 }
 
 namespace {
   /// A pass to extract specific global values and their dependencies.
   class GVExtractorPass : public ModulePass {
     SetVector<GlobalValue *> Named;
     bool deleteStuff;
+    bool keepConstInit;
   public:
     static char ID; // Pass identification, replacement for typeid
 
     /// If deleteS is true, this pass deletes the specified global values.
     /// Otherwise, it deletes as much of the module as possible, except for the
     /// global values specified.
     explicit GVExtractorPass(std::vector<GlobalValue*> &GVs,
-                             bool deleteS = true)
-      : ModulePass(ID), Named(GVs.begin(), GVs.end()), deleteStuff(deleteS) {}
+                             bool deleteS = true, bool keepConstInit = false)
+      : ModulePass(ID), Named(GVs.begin(), GVs.end()), deleteStuff(deleteS),
+        keepConstInit(keepConstInit) {}
 
     bool runOnModule(Module &M) override {
       if (skipModule(M))
         return false;
 
       // Visit the global inline asm.
       if (!deleteStuff)
         M.setModuleInlineAsm("");
 
       // For simplicity, just give all GlobalValues ExternalLinkage. A trickier
       // implementation could figure out which GlobalValues are actually
       // referenced by the Named set, and which GlobalValues in the rest of
       // the module are referenced by the NamedSet, and get away with leaving
       // more internal and private things internal and private. But for now,
       // be conservative and simple.
 
       // Visit the GlobalVariables.
       for (Module::global_iterator I = M.global_begin(), E = M.global_end();
            I != E; ++I) {
         bool Delete =
-            deleteStuff == (bool)Named.count(&*I) && !I->isDeclaration();
+            deleteStuff == (bool)Named.count(&*I) && !I->isDeclaration() &&
+            (!I->isConstant() || !keepConstInit);
         if (!Delete) {
           if (I->hasAvailableExternallyLinkage())
             continue;
           if (I->getName() == "llvm.global_ctors")
             continue;
         }
 
         makeVisible(*I, Delete);
bool runOnModule(Module &M) override {
       return true;
     }
   };
 
   char GVExtractorPass::ID = 0;
 }
 
 ModulePass *llvm::createGVExtractionPass(std::vector<GlobalValue *> &GVs,
-                                         bool deleteFn) {
-  return new GVExtractorPass(GVs, deleteFn);
+                                         bool deleteFn, bool keepConstInit) {
+  return new GVExtractorPass(GVs, deleteFn, keepConstInit);
 }

llvm/test/tools/llvm-extract/keep-constinit.ll

+; RUN: llvm-extract -func foo -keep-const-init -S < %s | FileCheck %s
+; RUN: llvm-extract -func foo -S < %s | FileCheck %s --check-prefix=CHECK2
+
+; CHECK: @cv = constant i32 0
+; CHECK2: @cv = external constant i32
+
+@cv = constant i32 0
+
+define i32 @foo() {
+  %v = load i32, i32* @cv
+  ret i32 %v
+}

llvm/tools/llvm-extract/llvm-extract.cpp

 
 static cl::opt<bool> Force("f", cl::desc("Enable binary output on terminals"),
                            cl::cat(ExtractCat));
 
 static cl::opt<bool> DeleteFn("delete",
                               cl::desc("Delete specified Globals from Module"),
                               cl::cat(ExtractCat));
 
+static cl::opt<bool> KeepConstInit("keep-const-init",
+                              cl::desc("Keep initializers of constants"),
+                              cl::cat(ExtractCat));
+
 static cl::opt<bool>
     Recursive("recursive", cl::desc("Recursively extract all called functions"),
               cl::cat(ExtractCat));
 
 // ExtractFuncs - The functions to extract from the module.
 static cl::list<std::string>
     ExtractFuncs("func", cl::desc("Specify function to extract"),
                  cl::ZeroOrMore, cl::value_desc("function"),
for (auto &F : *M) {
       if (!GVSet.count(&F))
         Materialize(F);
     }
   }
 
   {
     std::vector<GlobalValue *> Gvs(GVs.begin(), GVs.end());
     legacy::PassManager Extract;
-    Extract.add(createGVExtractionPass(Gvs, DeleteFn));
+    Extract.add(createGVExtractionPass(Gvs, DeleteFn, KeepConstInit));
     Extract.run(*M);
 
     // Now that we have all the GVs we want, mark the module as fully
     // materialized.
     // FIXME: should the GVExtractionPass handle this?
     ExitOnErr(M->materializeAll());
   }