llvm/lib/Transforms/IPO/Internalize.cpp

   1 //===-- Internalize.cpp - Mark functions internal -------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This pass loops over all of the functions and variables in the input module.
  10 // If the function or variable does not need to be preserved according to the
  11 // client supplied callback, it is marked as internal.
  12 //
  13 // This transformation would not be legal in a regular compilation, but it gets
  14 // extra information from the linker about what is safe.
  15 //
  16 // For example: Internalizing a function with external linkage. Only if we are
  17 // told it is only used from within this module, it is safe to do it.
  18 //
  19 //===----------------------------------------------------------------------===//
  20
  21 #include "llvm/Transforms/IPO/Internalize.h"
  22 #include "llvm/ADT/SmallString.h"
  23 #include "llvm/ADT/Statistic.h"
  24 #include "llvm/ADT/StringSet.h"
  25 #include "llvm/Analysis/CallGraph.h"
  26 #include "llvm/IR/Module.h"
  27 #include "llvm/Support/CommandLine.h"
  28 #include "llvm/Support/Debug.h"
  29 #include "llvm/Support/GlobPattern.h"
  30 #include "llvm/Support/LineIterator.h"
  31 #include "llvm/Support/MemoryBuffer.h"
  32 #include "llvm/Support/raw_ostream.h"
  33 #include "llvm/TargetParser/Triple.h"
  34 #include "llvm/Transforms/IPO.h"
  35 using namespace llvm;
  36
  37 #define DEBUG_TYPE "internalize"
  38
  39 STATISTIC(NumAliases, "Number of aliases internalized");
  40 STATISTIC(NumFunctions, "Number of functions internalized");
  41 STATISTIC(NumGlobals, "Number of global vars internalized");
  42
  43 // APIFile - A file which contains a list of symbol glob patterns that should
  44 // not be marked external.
  45 static cl::opt<std::string>
  46     APIFile("internalize-public-api-file", cl::value_desc("filename"),
  47             cl::desc("A file containing list of symbol names to preserve"));
  48
  49 // APIList - A list of symbol glob patterns that should not be marked internal.
  50 static cl::list<std::string>
  51     APIList("internalize-public-api-list", cl::value_desc("list"),
  52             cl::desc("A list of symbol names to preserve"), cl::CommaSeparated);
  53
  54 namespace {
  55 // Helper to load an API list to preserve from file and expose it as a functor
  56 // for internalization.
  57 class PreserveAPIList {
  58 public:
  59   PreserveAPIList() {
  60     if (!APIFile.empty())
  61       LoadFile(APIFile);
  62     for (StringRef Pattern : APIList)
  63       addGlob(Pattern);
  64   }
  65
  66   bool operator()(const GlobalValue &GV) {
  67     return llvm::any_of(
  68         ExternalNames, [&](GlobPattern &GP) { return GP.match(GV.getName()); });
  69   }
  70
  71 private:
  72   // Contains the set of symbols loaded from file
  73   SmallVector<GlobPattern> ExternalNames;
  74
  75   void addGlob(StringRef Pattern) {
  76     auto GlobOrErr = GlobPattern::create(Pattern);
  77     if (!GlobOrErr) {
  78       errs() << "WARNING: when loading pattern: '"
  79              << toString(GlobOrErr.takeError()) << "' ignoring";
  80       return;
  81     }
  82     ExternalNames.emplace_back(std::move(*GlobOrErr));
  83   }
  84
  85   void LoadFile(StringRef Filename) {
  86     // Load the APIFile...
  87     ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
  88         MemoryBuffer::getFile(Filename);
  89     if (!BufOrErr) {
  90       errs() << "WARNING: Internalize couldn't load file '" << Filename
  91              << "'! Continuing as if it's empty.\n";
  92       return; // Just continue as if the file were empty
  93     }
  94     Buf = std::move(*BufOrErr);
  95     for (line_iterator I(*Buf, true), E; I != E; ++I)
  96       addGlob(*I);
  97   }
  98
  99   std::shared_ptr<MemoryBuffer> Buf;
 100 };
 101 } // end anonymous namespace
 102
 103 bool InternalizePass::shouldPreserveGV(const GlobalValue &GV) {
 104   // Function must be defined here
 105   if (GV.isDeclaration())
 106     return true;
 107
 108   // Available externally is really just a "declaration with a body".
 109   if (GV.hasAvailableExternallyLinkage())
 110     return true;
 111
 112   // Assume that dllexported symbols are referenced elsewhere
 113   if (GV.hasDLLExportStorageClass())
 114     return true;
 115
 116   // As the name suggests, externally initialized variables need preserving as
 117   // they would be initialized elsewhere externally.
 118   if (const auto *G = dyn_cast<GlobalVariable>(&GV))
 119     if (G->isExternallyInitialized())
 120       return true;
 121
 122   // Already local, has nothing to do.
 123   if (GV.hasLocalLinkage())
 124     return false;
 125
 126   // Check some special cases
 127   if (AlwaysPreserved.count(GV.getName()))
 128     return true;
 129
 130   return MustPreserveGV(GV);
 131 }
 132
 133 bool InternalizePass::maybeInternalize(
 134     GlobalValue &GV, DenseMap<const Comdat *, ComdatInfo> &ComdatMap) {
 135   SmallString<0> ComdatName;
 136   if (Comdat *C = GV.getComdat()) {
 137     // For GlobalAlias, C is the aliasee object's comdat which may have been
 138     // redirected. So ComdatMap may not contain C.
 139     if (ComdatMap.lookup(C).External)
 140       return false;
 141
 142     if (auto *GO = dyn_cast<GlobalObject>(&GV)) {
 143       // If a comdat with one member is not externally visible, we can drop it.
 144       // Otherwise, the comdat can be used to establish dependencies among the
 145       // group of sections. Thus we have to keep the comdat but switch it to
 146       // nodeduplicate.
 147       // Note: nodeduplicate is not necessary for COFF. wasm doesn't support
 148       // nodeduplicate.
 149       ComdatInfo &Info = ComdatMap.find(C)->second;
 150       if (Info.Size == 1)
 151         GO->setComdat(nullptr);
 152       else if (!IsWasm)
 153         C->setSelectionKind(Comdat::NoDeduplicate);
 154     }
 155
 156     if (GV.hasLocalLinkage())
 157       return false;
 158   } else {
 159     if (GV.hasLocalLinkage())
 160       return false;
 161
 162     if (shouldPreserveGV(GV))
 163       return false;
 164   }
 165
 166   GV.setVisibility(GlobalValue::DefaultVisibility);
 167   GV.setLinkage(GlobalValue::InternalLinkage);
 168   return true;
 169 }
 170
 171 // If GV is part of a comdat and is externally visible, update the comdat size
 172 // and keep track of its comdat so that we don't internalize any of its members.
 173 void InternalizePass::checkComdat(
 174     GlobalValue &GV, DenseMap<const Comdat *, ComdatInfo> &ComdatMap) {
 175   Comdat *C = GV.getComdat();
 176   if (!C)
 177     return;
 178
 179   ComdatInfo &Info = ComdatMap.try_emplace(C).first->second;
 180   ++Info.Size;
 181   if (shouldPreserveGV(GV))
 182     Info.External = true;
 183 }
 184
 185 bool InternalizePass::internalizeModule(Module &M) {
 186   bool Changed = false;
 187
 188   SmallVector<GlobalValue *, 4> Used;
 189   collectUsedGlobalVariables(M, Used, false);
 190
 191   // Collect comdat size and visiblity information for the module.
 192   DenseMap<const Comdat *, ComdatInfo> ComdatMap;
 193   if (!M.getComdatSymbolTable().empty()) {
 194     for (Function &F : M)
 195       checkComdat(F, ComdatMap);
 196     for (GlobalVariable &GV : M.globals())
 197       checkComdat(GV, ComdatMap);
 198     for (GlobalAlias &GA : M.aliases())
 199       checkComdat(GA, ComdatMap);
 200   }
 201
 202   // We must assume that globals in llvm.used have a reference that not even
 203   // the linker can see, so we don't internalize them.
 204   // For llvm.compiler.used the situation is a bit fuzzy. The assembler and
 205   // linker can drop those symbols. If this pass is running as part of LTO,
 206   // one might think that it could just drop llvm.compiler.used. The problem
 207   // is that even in LTO llvm doesn't see every reference. For example,
 208   // we don't see references from function local inline assembly. To be
 209   // conservative, we internalize symbols in llvm.compiler.used, but we
 210   // keep llvm.compiler.used so that the symbol is not deleted by llvm.
 211   for (GlobalValue *V : Used) {
 212     AlwaysPreserved.insert(V->getName());
 213   }
 214
 215   // Never internalize the llvm.used symbol.  It is used to implement
 216   // attribute((used)).
 217   // FIXME: Shouldn't this just filter on llvm.metadata section??
 218   AlwaysPreserved.insert("llvm.used");
 219   AlwaysPreserved.insert("llvm.compiler.used");
 220
 221   // Never internalize anchors used by the machine module info, else the info
 222   // won't find them.  (see MachineModuleInfo.)
 223   AlwaysPreserved.insert("llvm.global_ctors");
 224   AlwaysPreserved.insert("llvm.global_dtors");
 225   AlwaysPreserved.insert("llvm.global.annotations");
 226
 227   // Never internalize symbols code-gen inserts.
 228   // FIXME: We should probably add this (and the __stack_chk_guard) via some
 229   // type of call-back in CodeGen.
 230   AlwaysPreserved.insert("__stack_chk_fail");
 231   if (Triple(M.getTargetTriple()).isOSAIX())
 232     AlwaysPreserved.insert("__ssp_canary_word");
 233   else
 234     AlwaysPreserved.insert("__stack_chk_guard");
 235
 236   // Mark all functions not in the api as internal.
 237   IsWasm = Triple(M.getTargetTriple()).isOSBinFormatWasm();
 238   for (Function &I : M) {
 239     if (!maybeInternalize(I, ComdatMap))
 240       continue;
 241     Changed = true;
 242
 243     ++NumFunctions;
 244     LLVM_DEBUG(dbgs() << "Internalizing func " << I.getName() << "\n");
 245   }
 246
 247   // Mark all global variables with initializers that are not in the api as
 248   // internal as well.
 249   for (auto &GV : M.globals()) {
 250     if (!maybeInternalize(GV, ComdatMap))
 251       continue;
 252     Changed = true;
 253
 254     ++NumGlobals;
 255     LLVM_DEBUG(dbgs() << "Internalized gvar " << GV.getName() << "\n");
 256   }
 257
 258   // Mark all aliases that are not in the api as internal as well.
 259   for (auto &GA : M.aliases()) {
 260     if (!maybeInternalize(GA, ComdatMap))
 261       continue;
 262     Changed = true;
 263
 264     ++NumAliases;
 265     LLVM_DEBUG(dbgs() << "Internalized alias " << GA.getName() << "\n");
 266   }
 267
 268   return Changed;
 269 }
 270
 271 InternalizePass::InternalizePass() : MustPreserveGV(PreserveAPIList()) {}
 272
 273 PreservedAnalyses InternalizePass::run(Module &M, ModuleAnalysisManager &AM) {
 274   if (!internalizeModule(M))
 275     return PreservedAnalyses::all();
 276
 277   return PreservedAnalyses::none();
 278 }