contrib/llvm/lib/Transforms/IPO/ExtractGV.cpp

   1 //===-- ExtractGV.cpp - Global Value extraction pass ----------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This pass extracts global values
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Transforms/IPO.h"
  15 #include "llvm/ADT/SetVector.h"
  16 #include "llvm/IR/Constants.h"
  17 #include "llvm/IR/Instructions.h"
  18 #include "llvm/IR/LLVMContext.h"
  19 #include "llvm/IR/Module.h"
  20 #include "llvm/Pass.h"
  21 #include <algorithm>
  22 using namespace llvm;
  23
  24 /// Make sure GV is visible from both modules. Delete is true if it is
  25 /// being deleted from this module.
  26 /// This also makes sure GV cannot be dropped so that references from
  27 /// the split module remain valid.
  28 static void makeVisible(GlobalValue &GV, bool Delete) {
  29   bool Local = GV.hasLocalLinkage();
  30   if (Local || Delete) {
  31     GV.setLinkage(GlobalValue::ExternalLinkage);
  32     if (Local)
  33       GV.setVisibility(GlobalValue::HiddenVisibility);
  34     return;
  35   }
  36
  37   if (!GV.hasLinkOnceLinkage()) {
  38     assert(!GV.isDiscardableIfUnused());
  39     return;
  40   }
  41
  42   // Map linkonce* to weak* so that llvm doesn't drop this GV.
  43   switch(GV.getLinkage()) {
  44   default:
  45     llvm_unreachable("Unexpected linkage");
  46   case GlobalValue::LinkOnceAnyLinkage:
  47     GV.setLinkage(GlobalValue::WeakAnyLinkage);
  48     return;
  49   case GlobalValue::LinkOnceODRLinkage:
  50     GV.setLinkage(GlobalValue::WeakODRLinkage);
  51     return;
  52   }
  53 }
  54
  55 namespace {
  56   /// @brief A pass to extract specific functions and their dependencies.
  57   class GVExtractorPass : public ModulePass {
  58     SetVector<GlobalValue *> Named;
  59     bool deleteStuff;
  60   public:
  61     static char ID; // Pass identification, replacement for typeid
  62
  63     /// FunctionExtractorPass - If deleteFn is true, this pass deletes as the
  64     /// specified function. Otherwise, it deletes as much of the module as
  65     /// possible, except for the function specified.
  66     ///
  67     explicit GVExtractorPass(std::vector<GlobalValue*>& GVs, bool deleteS = true)
  68       : ModulePass(ID), Named(GVs.begin(), GVs.end()), deleteStuff(deleteS) {}
  69
  70     bool runOnModule(Module &M) override {
  71       if (skipModule(M))
  72         return false;
  73
  74       // Visit the global inline asm.
  75       if (!deleteStuff)
  76         M.setModuleInlineAsm("");
  77
  78       // For simplicity, just give all GlobalValues ExternalLinkage. A trickier
  79       // implementation could figure out which GlobalValues are actually
  80       // referenced by the Named set, and which GlobalValues in the rest of
  81       // the module are referenced by the NamedSet, and get away with leaving
  82       // more internal and private things internal and private. But for now,
  83       // be conservative and simple.
  84
  85       // Visit the GlobalVariables.
  86       for (Module::global_iterator I = M.global_begin(), E = M.global_end();
  87            I != E; ++I) {
  88         bool Delete =
  89             deleteStuff == (bool)Named.count(&*I) && !I->isDeclaration();
  90         if (!Delete) {
  91           if (I->hasAvailableExternallyLinkage())
  92             continue;
  93           if (I->getName() == "llvm.global_ctors")
  94             continue;
  95         }
  96
  97         makeVisible(*I, Delete);
  98
  99         if (Delete) {
 100           // Make this a declaration and drop it's comdat.
 101           I->setInitializer(nullptr);
 102           I->setComdat(nullptr);
 103         }
 104       }
 105
 106       // Visit the Functions.
 107       for (Function &F : M) {
 108         bool Delete =
 109             deleteStuff == (bool)Named.count(&F) && !F.isDeclaration();
 110         if (!Delete) {
 111           if (F.hasAvailableExternallyLinkage())
 112             continue;
 113         }
 114
 115         makeVisible(F, Delete);
 116
 117         if (Delete) {
 118           // Make this a declaration and drop it's comdat.
 119           F.deleteBody();
 120           F.setComdat(nullptr);
 121         }
 122       }
 123
 124       // Visit the Aliases.
 125       for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end();
 126            I != E;) {
 127         Module::alias_iterator CurI = I;
 128         ++I;
 129
 130         bool Delete = deleteStuff == (bool)Named.count(&*CurI);
 131         makeVisible(*CurI, Delete);
 132
 133         if (Delete) {
 134           Type *Ty =  CurI->getValueType();
 135
 136           CurI->removeFromParent();
 137           llvm::Value *Declaration;
 138           if (FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
 139             Declaration = Function::Create(FTy, GlobalValue::ExternalLinkage,
 140                                            CurI->getName(), &M);
 141
 142           } else {
 143             Declaration =
 144               new GlobalVariable(M, Ty, false, GlobalValue::ExternalLinkage,
 145                                  nullptr, CurI->getName());
 146
 147           }
 148           CurI->replaceAllUsesWith(Declaration);
 149           delete &*CurI;
 150         }
 151       }
 152
 153       return true;
 154     }
 155   };
 156
 157   char GVExtractorPass::ID = 0;
 158 }
 159
 160 ModulePass *llvm::createGVExtractionPass(std::vector<GlobalValue *> &GVs,
 161                                          bool deleteFn) {
 162   return new GVExtractorPass(GVs, deleteFn);
 163 }