Rebased PNaCl localmods in LLVM to 223109

tools/gold/gold-plugin.cpp

 //===-- gold-plugin.cpp - Plugin to gold for Link Time Optimization  ------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This is a gold plugin for LLVM. It provides an LLVM implementation of the
@@ skipping 60 matching lines @@
 static ld_plugin_add_input_file add_input_file = nullptr;
 static ld_plugin_set_extra_library_path set_extra_library_path = nullptr;
 static ld_plugin_get_view get_view = nullptr;
 static ld_plugin_message message = discard_message;
 static Reloc::Model RelocationModel = Reloc::Default;
 static std::string output_name = "";
 static std::list<claimed_file> Modules;
 static std::vector<std::string> Cleanup;
 static llvm::TargetOptions TargetOpts;
 
+// @LOCALMOD-BEGIN
+// Callback for getting the number of --wrap'd symbols.
+static ld_plugin_get_num_wrapped get_num_wrapped = NULL;
+
+// Callback for getting the name of a wrapped symbol.
+static ld_plugin_get_wrapped get_wrapped = NULL;
+// @LOCALMOD-END
+
 namespace options {
   enum OutputType {
     OT_NORMAL,
     OT_DISABLE,
     OT_BC_ONLY,
     OT_SAVE_TEMPS
   };
   static bool generate_api_file = false;
   static OutputType TheOutputType = OT_NORMAL;
   static std::string obj_path;
@@ skipping 125 matching lines @@
         break;
       case LDPT_ADD_INPUT_FILE:
         add_input_file = tv->tv_u.tv_add_input_file;
         break;
       case LDPT_SET_EXTRA_LIBRARY_PATH:
         set_extra_library_path = tv->tv_u.tv_set_extra_library_path;
         break;
       case LDPT_GET_VIEW:
         get_view = tv->tv_u.tv_get_view;
         break;
+      // @LOCALMOD-BEGIN
+      case LDPT_GET_WRAPPED:
+        get_wrapped = tv->tv_u.tv_get_wrapped;
+        break;
+      case LDPT_GET_NUM_WRAPPED:
+        get_num_wrapped = tv->tv_u.tv_get_num_wrapped;
+        break;
+      // @LOCALMOD-END
       case LDPT_MESSAGE:
         message = tv->tv_u.tv_message;
         break;
       default:
         break;
     }
   }
 
   if (!registeredClaimFile) {
     message(LDPL_ERROR, "register_claim_file not passed to LLVMgold.");
@@ skipping 300 matching lines @@
   assert(!isa<GlobalAlias>(GV) && "Found alias point to weak alias.");
   return makeInternalReplacement(cast<GlobalObject>(GV));
 }
 
 static Constant *mapConstantToLocalCopy(Constant *C, ValueToValueMapTy &VM,
                                         LocalValueMaterializer *Materializer) {
   return MapValue(C, VM, RF_IgnoreMissingEntries, nullptr, Materializer);
 }
 
 static std::unique_ptr<Module>
-getModuleForFile(LLVMContext &Context, claimed_file &F, raw_fd_ostream *ApiFile,
+getModuleForFile(LLVMContext &Context, claimed_file &F,
+                 off_t Filesize, raw_fd_ostream *ApiFile,
                  StringSet<> &Internalize, StringSet<> &Maybe) {
-  ld_plugin_input_file File;
-  if (get_input_file(F.handle, &File) != LDPS_OK)
-    message(LDPL_FATAL, "Failed to get file information");
 
   if (get_symbols(F.handle, F.syms.size(), &F.syms[0]) != LDPS_OK)
     message(LDPL_FATAL, "Failed to get symbol information");
 
   const void *View;
   if (get_view(F.handle, &View) != LDPS_OK)
     message(LDPL_FATAL, "Failed to get a view of file");
 
   llvm::ErrorOr<MemoryBufferRef> MBOrErr =
       object::IRObjectFile::findBitcodeInMemBuffer(
-          MemoryBufferRef(StringRef((const char *)View, File.filesize), ""));
+          MemoryBufferRef(StringRef((const char *)View, Filesize), ""));
   if (std::error_code EC = MBOrErr.getError())
     message(LDPL_FATAL, "Could not read bitcode from file : %s",
             EC.message().c_str());
 
   std::unique_ptr<MemoryBuffer> Buffer =
       MemoryBuffer::getMemBuffer(MBOrErr->getBuffer(), "", false);
 
-  if (release_input_file(F.handle) != LDPS_OK)
-    message(LDPL_FATAL, "Failed to release file information");
-
   ErrorOr<Module *> MOrErr = getLazyBitcodeModule(std::move(Buffer), Context);
 
   if (std::error_code EC = MOrErr.getError())
     message(LDPL_FATAL, "Could not read bitcode from file : %s",
             EC.message().c_str());
 
   std::unique_ptr<Module> M(MOrErr.get());
 
   SmallPtrSet<GlobalValue *, 8> Used;
   collectUsedGlobalVariables(*M, Used, /*CompilerUsed*/ false);
@@ skipping 171 matching lines @@
 
   if (add_input_file(Filename.c_str()) != LDPS_OK)
     message(LDPL_FATAL,
             "Unable to add .o file to the link. File left behind in: %s",
             Filename.c_str());
 
   if (options::obj_path.empty())
     Cleanup.push_back(Filename.c_str());
 }
 
+// @LOCALMOD-BEGIN
+static void wrapSymbol(Module *M, const char *sym) {
+  std::string wrapSymName("__wrap_");
+  wrapSymName += sym;
+  std::string realSymName("__real_");
+  realSymName += sym;
+
+  Constant *SymGV = M->getNamedValue(sym);
+
+  // Replace uses of "sym" with "__wrap_sym".
+  if (SymGV) {
+    Constant *WrapGV = M->getNamedValue(wrapSymName);
+    if (!WrapGV)
+      WrapGV = M->getOrInsertGlobal(wrapSymName, SymGV->getType());
+    SymGV->replaceAllUsesWith(
+        ConstantExpr::getBitCast(WrapGV, SymGV->getType()));
+  }
+
+  // Replace uses of "__real_sym" with "sym".
+  if (Constant *RealGV = M->getNamedValue(realSymName)) {
+    if (!SymGV)
+      SymGV = M->getOrInsertGlobal(sym, RealGV->getType());
+    RealGV->replaceAllUsesWith(
+        ConstantExpr::getBitCast(SymGV, RealGV->getType()));
+  }
+}
+// @LOCALMOD-END
+
 /// gold informs us that all symbols have been read. At this point, we use
 /// get_symbols to see if any of our definitions have been overridden by a
 /// native object file. Then, perform optimization and codegen.
 static ld_plugin_status allSymbolsReadHook(raw_fd_ostream *ApiFile) {
   if (Modules.empty())
     return LDPS_OK;
 
   LLVMContext Context;
   std::unique_ptr<Module> Combined(new Module("ld-temp.o", Context));
   Linker L(Combined.get());
 
   std::string DefaultTriple = sys::getDefaultTargetTriple();
 
   StringSet<> Internalize;
   StringSet<> Maybe;
   for (claimed_file &F : Modules) {
+    ld_plugin_input_file File;
+    if (get_input_file(F.handle, &File) != LDPS_OK)
+      message(LDPL_FATAL, "Failed to get file information");
     std::unique_ptr<Module> M =
-        getModuleForFile(Context, F, ApiFile, Internalize, Maybe);
+        getModuleForFile(Context, F, File.filesize, ApiFile,
+                         Internalize, Maybe);
     if (!options::triple.empty())
       M->setTargetTriple(options::triple.c_str());
     else if (M->getTargetTriple().empty()) {
       M->setTargetTriple(DefaultTriple);
     }
 
     if (L.linkInModule(M.get()))
       message(LDPL_FATAL, "Failed to link module");
+    if (release_input_file(F.handle) != LDPS_OK)
+      message(LDPL_FATAL, "Failed to release file information");
   }
 
   for (const auto &Name : Internalize) {
     GlobalValue *GV = Combined->getNamedValue(Name.first());
     if (GV)
       internalize(*GV);
   }
 
   for (const auto &Name : Maybe) {
     GlobalValue *GV = Combined->getNamedValue(Name.first());
     if (!GV)
       continue;
     GV->setLinkage(GlobalValue::LinkOnceODRLinkage);
     if (canBeOmittedFromSymbolTable(GV))
       internalize(*GV);
   }
 
+  // @LOCALMOD-BEGIN
+  // Perform symbol wrapping.
+  unsigned num_wrapped;
+  if ((*get_num_wrapped)(&num_wrapped) != LDPS_OK) {
+    (*message)(LDPL_ERROR, "Unable to get the number of wrapped symbols.");
+    return LDPS_ERR;
+  }
+  for (unsigned i = 0; i < num_wrapped; ++i) {
+    const char *sym;
+    if ((*get_wrapped)(i, &sym) != LDPS_OK) {
+      (*message)(LDPL_ERROR, "Unable to wrap symbol %u/%u.", i, num_wrapped);
+      return LDPS_ERR;
+    }
+    wrapSymbol(Combined.get(), sym);
+  }
+  // @LOCALMOD-END
+
   if (options::TheOutputType == options::OT_DISABLE)
     return LDPS_OK;
 
   if (options::TheOutputType != options::OT_NORMAL) {
     std::string path;
     if (options::TheOutputType == options::OT_BC_ONLY)
       path = output_name;
     else
       path = output_name + ".bc";
     saveBCFile(path, *L.getModule());
@@ skipping 35 matching lines @@
 static ld_plugin_status cleanup_hook(void) {
   for (std::string &Name : Cleanup) {
     std::error_code EC = sys::fs::remove(Name);
     if (EC)
       message(LDPL_ERROR, "Failed to delete '%s': %s", Name.c_str(),
               EC.message().c_str());
   }
 
   return LDPS_OK;
 }