Revert "Reapply "LTO: add API to set strategy for -internalize""

This reverts commit r199244.

Conflicts:
	include/llvm-c/lto.h
	include/llvm/LTO/LTOCodeGenerator.h
	lib/LTO/LTOCodeGenerator.cpp

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@205471 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm-c/lto.h b/include/llvm-c/lto.h
index 87904c208cc23693d76c07712ea978223b7481ec..049c4d75175bb991d950d820252381e5b1688d24 100644 (file)
--- a/include/llvm-c/lto.h
+++ b/include/llvm-c/lto.h
@@ -82,15 +82,6 @@ typedef enum {
     LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC = 2
 } lto_codegen_model;
 
-/**
- * \since LTO_API_VERSION=6
- */
-typedef enum {
-    LTO_INTERNALIZE_FULL   = 0,
-    LTO_INTERNALIZE_NONE   = 1,
-    LTO_INTERNALIZE_HIDDEN = 2
-} lto_internalize_strategy;
-
 /** opaque reference to a loaded object module */
 typedef struct LTOModule*         lto_module_t;
 
@@ -402,16 +393,6 @@ extern void
 lto_codegen_set_assembler_args(lto_code_gen_t cg, const char **args,
                                int nargs);
 
-/**
- * Sets the strategy to use during internalize.  Default strategy is
- * LTO_INTERNALIZE_FULL.
- *
- * \since LTO_API_VERSION=6
- */
-extern void
-lto_codegen_set_internalize_strategy(lto_code_gen_t cg,
-                                     lto_internalize_strategy);
-
 /**
  * Tells LTO optimization passes that this symbol must be preserved
  * because it is referenced by native code or a command line option.

diff --git a/include/llvm/LTO/LTOCodeGenerator.h b/include/llvm/LTO/LTOCodeGenerator.h
index ee2b2088914c4a5f32e75c9898ba05b706b3a1ba..543399157b4f7551df9c5afb05ce74a33af03b57 100644 (file)
--- a/include/llvm/LTO/LTOCodeGenerator.h
+++ b/include/llvm/LTO/LTOCodeGenerator.h
@@ -71,7 +71,6 @@ struct LTOCodeGenerator {
   void setTargetOptions(llvm::TargetOptions options);
   void setDebugInfo(lto_debug_model);
   void setCodePICModel(lto_codegen_model);
-  void setInternalizeStrategy(lto_internalize_strategy);
 
   void setCpu(const char *mCpu) { MCpu = mCpu; }
 
@@ -118,14 +117,6 @@ struct LTOCodeGenerator {
 
   void setDiagnosticHandler(lto_diagnostic_handler_t, void *);
 
-  bool shouldInternalize() const {
-    return InternalizeStrategy != LTO_INTERNALIZE_NONE;
-  }
-
-  bool shouldOnlyInternalizeHidden() const {
-    return InternalizeStrategy == LTO_INTERNALIZE_HIDDEN;
-  }
-
 private:
   void initializeLTOPasses();
 
@@ -154,7 +145,6 @@ private:
   bool EmitDwarfDebugInfo;
   bool ScopeRestrictionsDone;
   lto_codegen_model CodeModel;
-  lto_internalize_strategy InternalizeStrategy;
   StringSet MustPreserveSymbols;
   StringSet AsmUndefinedRefs;
   llvm::MemoryBuffer *NativeObjectFile;

diff --git a/include/llvm/Transforms/IPO.h b/include/llvm/Transforms/IPO.h
index ae9d5c1d09b6962df2e987d3cd9fd4979a9ed3e1..334fb1cc4d3ad0f798473331747fac008304e68c 100644 (file)
--- a/include/llvm/Transforms/IPO.h
+++ b/include/llvm/Transforms/IPO.h
@@ -112,19 +112,14 @@ Pass *createPruneEHPass();
 ////
 /// The symbols in \p ExportList are never internalized.
 ///
-/// When OnlyHidden=true, only symbols with hidden visibility are internalized.
-///
 /// The symbol in DSOList are internalized if it is safe to drop them from
 /// the symbol table.
 ///
 /// Note that commandline options that are used with the above function are not
 /// used now!
-ModulePass *createInternalizePass(ArrayRef<const char *> ExportList,
-                                  bool OnlyHidden = false);
+ModulePass *createInternalizePass(ArrayRef<const char *> ExportList);
 /// createInternalizePass - Same as above, but with an empty exportList.
-ModulePass *createInternalizePass(bool OnlyHidden = false);
-/// createInternalizePass - Resolve ambiguity when passed a const char *.
-ModulePass *createInternalizePass(const char *SingleExport);
+ModulePass *createInternalizePass();
 
 //===----------------------------------------------------------------------===//
 /// createDeadArgEliminationPass - This pass removes arguments from functions

diff --git a/lib/LTO/LTOCodeGenerator.cpp b/lib/LTO/LTOCodeGenerator.cpp
index b7f41357af82f591eda8eab32552fe60a5cb0db3..51d089988178fb40d39966b25c9b820a2fba8fa7 100644 (file)
--- a/lib/LTO/LTOCodeGenerator.cpp
+++ b/lib/LTO/LTOCodeGenerator.cpp
@@ -65,8 +65,7 @@ const char* LTOCodeGenerator::getVersionString() {
 LTOCodeGenerator::LTOCodeGenerator()
     : Context(getGlobalContext()), Linker(new Module("ld-temp.o", Context)),
       TargetMach(NULL), EmitDwarfDebugInfo(false), ScopeRestrictionsDone(false),
-      CodeModel(LTO_CODEGEN_PIC_MODEL_DYNAMIC),
-      InternalizeStrategy(LTO_INTERNALIZE_FULL), NativeObjectFile(NULL),
+      CodeModel(LTO_CODEGEN_PIC_MODEL_DYNAMIC), NativeObjectFile(NULL),
       DiagHandler(NULL), DiagContext(NULL) {
   initializeLTOPasses();
 }
@@ -169,18 +168,6 @@ void LTOCodeGenerator::setCodePICModel(lto_codegen_model model) {
   llvm_unreachable("Unknown PIC model!");
 }
 
-void
-LTOCodeGenerator::setInternalizeStrategy(lto_internalize_strategy Strategy) {
-  switch (Strategy) {
-  case LTO_INTERNALIZE_FULL:
-  case LTO_INTERNALIZE_NONE:
-  case LTO_INTERNALIZE_HIDDEN:
-    InternalizeStrategy = Strategy;
-    return;
-  }
-  llvm_unreachable("Unknown internalize strategy!");
-}
-
 bool LTOCodeGenerator::writeMergedModules(const char *path,
                                           std::string &errMsg) {
   if (!determineTarget(errMsg))
@@ -402,7 +389,7 @@ static void accumulateAndSortLibcalls(std::vector<StringRef> &Libcalls,
 }
 
 void LTOCodeGenerator::applyScopeRestrictions() {
-  if (ScopeRestrictionsDone || !shouldInternalize())
+  if (ScopeRestrictionsDone)
     return;
   Module *mergedModule = Linker.getModule();
 
@@ -454,8 +441,7 @@ void LTOCodeGenerator::applyScopeRestrictions() {
     LLVMCompilerUsed->setSection("llvm.metadata");
   }
 
-  passes.add(
-      createInternalizePass(MustPreserveList, shouldOnlyInternalizeHidden()));
+  passes.add(createInternalizePass(MustPreserveList));
 
   // apply scope restrictions
   passes.run(*mergedModule);

diff --git a/lib/Transforms/IPO/Internalize.cpp b/lib/Transforms/IPO/Internalize.cpp
index 29a01bd080f5059ca5bc9fbb5f1ba2b7427140bd..c1fe01cebcd18fea2957cd82f9332e575530e12b 100644 (file)
--- a/lib/Transforms/IPO/Internalize.cpp
+++ b/lib/Transforms/IPO/Internalize.cpp
@@ -54,11 +54,10 @@ APIList("internalize-public-api-list", cl::value_desc("list"),
 namespace {
   class InternalizePass : public ModulePass {
     std::set<std::string> ExternalNames;
-    bool OnlyHidden;
   public:
     static char ID; // Pass identification, replacement for typeid
-    explicit InternalizePass(bool OnlyHidden = false);
-    explicit InternalizePass(ArrayRef<const char *> ExportList, bool OnlyHidden);
+    explicit InternalizePass();
+    explicit InternalizePass(ArrayRef<const char *> ExportList);
     void LoadFile(const char *Filename);
     bool runOnModule(Module &M) override;
 
@@ -73,17 +72,15 @@ char InternalizePass::ID = 0;
 INITIALIZE_PASS(InternalizePass, "internalize",
                 "Internalize Global Symbols", false, false)
 
-InternalizePass::InternalizePass(bool OnlyHidden)
-  : ModulePass(ID), OnlyHidden(OnlyHidden) {
+InternalizePass::InternalizePass() : ModulePass(ID) {
   initializeInternalizePassPass(*PassRegistry::getPassRegistry());
   if (!APIFile.empty())           // If a filename is specified, use it.
     LoadFile(APIFile.c_str());
   ExternalNames.insert(APIList.begin(), APIList.end());
 }
 
-InternalizePass::InternalizePass(ArrayRef<const char *> ExportList,
-                                 bool OnlyHidden)
-  : ModulePass(ID), OnlyHidden(OnlyHidden) {
+InternalizePass::InternalizePass(ArrayRef<const char *> ExportList)
+    : ModulePass(ID) {
   initializeInternalizePassPass(*PassRegistry::getPassRegistry());
   for(ArrayRef<const char *>::const_iterator itr = ExportList.begin();
         itr != ExportList.end(); itr++) {
@@ -108,11 +105,7 @@ void InternalizePass::LoadFile(const char *Filename) {
 }
 
 static bool shouldInternalize(const GlobalValue &GV,
-                              const std::set<std::string> &ExternalNames,
-                              bool OnlyHidden) {
-  if (OnlyHidden && !GV.hasHiddenVisibility())
-    return false;
-
+                              const std::set<std::string> &ExternalNames) {
   // Function must be defined here
   if (GV.isDeclaration())
     return false;
@@ -162,7 +155,7 @@ bool InternalizePass::runOnModule(Module &M) {
 
   // Mark all functions not in the api as internal.
   for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
-    if (!shouldInternalize(*I, ExternalNames, OnlyHidden))
+    if (!shouldInternalize(*I, ExternalNames))
       continue;
 
     I->setLinkage(GlobalValue::InternalLinkage);
@@ -198,7 +191,7 @@ bool InternalizePass::runOnModule(Module &M) {
   // internal as well.
   for (Module::global_iterator I = M.global_begin(), E = M.global_end();
        I != E; ++I) {
-    if (!shouldInternalize(*I, ExternalNames, OnlyHidden))
+    if (!shouldInternalize(*I, ExternalNames))
       continue;
 
     I->setLinkage(GlobalValue::InternalLinkage);
@@ -210,7 +203,7 @@ bool InternalizePass::runOnModule(Module &M) {
   // Mark all aliases that are not in the api as internal as well.
   for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end();
        I != E; ++I) {
-    if (!shouldInternalize(*I, ExternalNames, OnlyHidden))
+    if (!shouldInternalize(*I, ExternalNames))
       continue;
 
     I->setLinkage(GlobalValue::InternalLinkage);
@@ -222,15 +215,8 @@ bool InternalizePass::runOnModule(Module &M) {
   return Changed;
 }
 
-ModulePass *llvm::createInternalizePass(bool OnlyHidden) {
-  return new InternalizePass(OnlyHidden);
-}
-
-ModulePass *llvm::createInternalizePass(ArrayRef<const char *> ExportList,
-                                        bool OnlyHidden) {
-  return new InternalizePass(ExportList, OnlyHidden);
-}
+ModulePass *llvm::createInternalizePass() { return new InternalizePass(); }
 
-ModulePass *llvm::createInternalizePass(const char *SingleExport) {
-  return createInternalizePass(ArrayRef<const char *>(SingleExport));
+ModulePass *llvm::createInternalizePass(ArrayRef<const char *> ExportList) {
+  return new InternalizePass(ExportList);
 }

diff --git a/tools/lto/lto.cpp b/tools/lto/lto.cpp
index 1b1e4626effb9ed0da84370e5122e23a4736f2f2..cc8318a8ba2e0735043c11f521194316e568b0a7 100644 (file)
--- a/tools/lto/lto.cpp
+++ b/tools/lto/lto.cpp
@@ -264,13 +264,6 @@ void lto_codegen_set_assembler_args(lto_code_gen_t cg, const char **args,
   // In here only for backwards compatibility. We use MC now.
 }
 
-/// lto_codegen_set_internalize_strategy - Sets the strategy to use during
-/// internalize.
-void lto_codegen_set_internalize_strategy(lto_code_gen_t cg,
-                                          lto_internalize_strategy strategy) {
-  cg->setInternalizeStrategy(strategy);
-}
-
 /// lto_codegen_add_must_preserve_symbol - Adds to a list of all global symbols
 /// that must exist in the final generated code. If a function is not listed
 /// there, it might be inlined into every usage and optimized away.