Add Gold plugin LTO support for pagerando

[rinon]

Summary

Pagerando bins need to be assigned to unique segments and marked with a flag to
designate the segment as pagerando-compatible. This patch adds support to the
gold plugin to assign pagerando bin sections to unique PF_RAND_ADDR flagged
segments.

This patch depends on gold to allow plugins to assign sections from plugin-generated
files to unique segments. This feature was added to gold in commit
c4e648430f3c5c135310f87280d45dba581aaa7b on 2017-12-11.

This patch set (D37580, D37581, D37582, D37583, D37584, D37585, D37586, D37587)
is a first draft of the pagerando implementation described in
http://lists.llvm.org/pipermail/llvm-dev/2017-June/113794.html.

[rinon]

This patch set (D37580, D37581, D37582, D37583, D37584, D37585, D37586, D37587) is a first draft of the pagerando implementation described in http://lists.llvm.org/pipermail/llvm-dev/2017-June/113794.html.

[rinon]

Rebase

[rinon]

Fix use-after-free of segment name when assigning to unique segments

[rinon]

Rebase

[rinon]

Rebase

[rinon]

• Update after pagerando binning refactoring

[rinon]

Rebase

[rinon]

Rebase

[rinon]

Rebase

include/llvm/BinaryFormat/ELF.h

enum {
   PT_WEBASSEMBLY_FUNCTIONS = PT_LOPROC + 0, // Function definitions.
 };
 
 // Segment flag bits.
 enum : unsigned {
   PF_X = 1,                // Execute
   PF_W = 2,                // Write
   PF_R = 4,                // Read
+  PF_RAND_ADDR = 0x00100000, // Random segment base address
   PF_MASKOS = 0x0ff00000,  // Bits for operating system-specific semantics.
   PF_MASKPROC = 0xf0000000 // Bits for processor-specific semantics.
 };
 
 // Dynamic table entry for ELF32.
 struct Elf32_Dyn {
   Elf32_Sword d_tag; // Type of dynamic table entry.
   union {

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
 // interface described in http://gcc.gnu.org/wiki/whopr/driver .
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/Statistic.h"
+#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/CodeGen/CommandFlags.h"
+#include "llvm/CodeGen/PagerandoBinning.h"
 #include "llvm/Config/config.h" // plugin-api.h requires HAVE_STDINT_H
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/LTO/Caching.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/CommandLine.h"

 
 }
 
 static ld_plugin_add_symbols add_symbols = nullptr;
 static ld_plugin_get_symbols get_symbols = nullptr;
 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_get_input_section_count get_input_section_count = nullptr;
+static ld_plugin_get_input_section_type get_input_section_type = nullptr;
+static ld_plugin_get_input_section_name get_input_section_name = nullptr;
+static ld_plugin_allow_unique_segment_for_sections allow_unique_segments = nullptr;
+static ld_plugin_unique_segment_for_sections unique_segments = nullptr;
 static bool IsExecutable = false;
 static Optional<Reloc::Model> RelocationModel = None;
 static std::string output_name = "";
 static std::list<claimed_file> Modules;
 static DenseMap<int, void *> FDToLeaderHandle;
 static StringMap<ResolutionInfo> ResInfo;
 static std::vector<std::string> Cleanup;
 
#endif
   // Additional options to pass into the code generator.
   // Note: This array will contain all plugin options which are not claimed
   // as plugin exclusive to pass to the code generator.
   static std::vector<const char *> extra;
   // Sample profile file path
   static std::string sample_profile;
   // New pass manager
   static bool new_pass_manager = false;
+  // Pagerando section prefix
+  static std::string PagerandoSectionPrefix = std::string(".text")
+                                              + PagerandoBinning::SectionPrefix;
 
   static void process_plugin_option(const char *opt_)
   {
     if (opt_ == nullptr)
       return;
     llvm::StringRef opt = opt_;
 
     if (opt.startswith("mcpu=")) {
if (opt.startswith("mcpu=")) {
       extra.push_back(opt_);
     }
   }
 }
 
 static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file,
                                         int *claimed);
 static ld_plugin_status all_symbols_read_hook(void);
+static ld_plugin_status new_input_hook(const ld_plugin_input_file *file);
 static ld_plugin_status cleanup_hook(void);
 
 extern "C" ld_plugin_status onload(ld_plugin_tv *tv);
 ld_plugin_status onload(ld_plugin_tv *tv) {
   InitializeAllTargetInfos();
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmParsers();
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;
     case LDPT_MESSAGE:
       message = tv->tv_u.tv_message;
       break;
+    case LDPT_GET_INPUT_SECTION_COUNT:
+      get_input_section_count = tv->tv_u.tv_get_input_section_count;
+      break;
+    case LDPT_GET_INPUT_SECTION_TYPE:
+      get_input_section_type = tv->tv_u.tv_get_input_section_type;
+      break;
+    case LDPT_GET_INPUT_SECTION_NAME:
+      get_input_section_name = tv->tv_u.tv_get_input_section_name;
+      break;
+    case LDPT_ALLOW_UNIQUE_SEGMENT_FOR_SECTIONS:
+      allow_unique_segments = tv->tv_u.tv_allow_unique_segment_for_sections;
+      break;
+    case LDPT_UNIQUE_SEGMENT_FOR_SECTIONS:
+      unique_segments = tv->tv_u.tv_unique_segment_for_sections;
+      break;
+    case LDPT_REGISTER_NEW_INPUT_HOOK: {
+      ld_plugin_register_new_input callback;
+      callback = tv->tv_u.tv_register_new_input;
+
+      if (callback(new_input_hook) != LDPS_OK)
+        return LDPS_ERR;
+    } break;
     default:
       break;
     }
   }
 
   if (!registeredClaimFile) {
     message(LDPL_ERROR, "register_claim_file not passed to LLVMgold.");
     return LDPS_ERR;
if (!get_input_file) {
     message(LDPL_ERROR, "get_input_file not passed to LLVMgold.");
     return LDPS_ERR;
   }
   if (!release_input_file) {
     message(LDPL_ERROR, "release_input_file not passed to LLVMgold.");
     return LDPS_ERR;
   }
 
+  if (RelocationModel == Reloc::PIP) {
+    // We need unique section->segment mapping to implement independently
+    // loadable segments
+    allow_unique_segments();
+  }
+
   return LDPS_OK;
 }
 
 static void diagnosticHandler(const DiagnosticInfo &DI) {
   std::string ErrStorage;
   {
     raw_string_ostream OS(ErrStorage);
     DiagnosticPrinterRawOStream DP(OS);
if (options::TheOutputType == options::OT_DISABLE) {
                 EC.message().c_str());
     }
     exit(0);
   }
 
   return Ret;
 }
 
+static ld_plugin_status new_input_hook(const ld_plugin_input_file *file) {
+  if (RelocationModel != Reloc::PIP)
+    return LDPS_OK;
+
+  unsigned int count;
+  if (get_input_section_count(file->handle, &count) != LDPS_OK) {
+    // Not an ELF file
+    return LDPS_OK;
+  }
+
+  struct ld_plugin_section cur_section;
+  cur_section.handle = file->handle;
+  for (unsigned i = 0; i < count; ++i) {
+    cur_section.shndx = i;
+    unsigned int type;
+    if (get_input_section_type(cur_section, &type) != LDPS_OK)
+      message(LDPL_FATAL, "Failed to get input section type");
+    if (type != ELF::SHT_PROGBITS)
+      continue;
+
+    char *name;
+    if (get_input_section_name(cur_section, &name) != LDPS_OK)
+      message(LDPL_FATAL, "Failed to get input section type");
+
+    StringRef name_str(name);
+    bool is_bin = name_str.startswith(options::PagerandoSectionPrefix);
+    bool is_pot = name_str.equals(".pot");
+    if (is_bin || is_pot) {
+      unsigned flags = ELF::PF_R | ELF::PF_RAND_ADDR |
+                       (is_bin ? ELF::PF_X : ELF::PF_W);
+      unique_segments(name, /* segment_name */
+                      flags, /* p_flags */
+                      4096, /* aligment */
+                      &cur_section, /* section_list */
+                      1); /* num_sections */
+    }
+    std::free(name);
+  }
+
+  return LDPS_OK;
+}
+
 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());
   }
 
   // Prune cache
   if (!options::cache_policy.empty()) {
     CachePruningPolicy policy = check(parseCachePruningPolicy(options::cache_policy));
     pruneCache(options::cache_dir, policy);
   }
 
   return LDPS_OK;
 }