[BOLT] Section-handling refactoring/overhaul

[maksfb]

Summary

Simplify the logic of handling sections in BOLT. This change brings more
direct and predictable mapping of BinarySection instances to sections in
the input and output files.

• Only sections from the input binary will have a non-null SectionRef. When a new section is created as a copy of the input section, its SectionRef is reset to null.

• RewriteInstance::getOutputSectionName() is removed as the section name in the output file is now defined by BinarySection::getOutputName().

• Querying BinaryContext for sections by name uses their original name. E.g., getUniqueSectionByName(".rodata") will return the original section even if the new .rodata section was created.

• Input file sections (with relocations applied) are emitted via MC with ".bolt.org" prefix. However, their name in the output binary is unchanged unless a new section with the same name is created.

• New sections are emitted internally with ".bolt.new" prefix if there's a name conflict with an input file section. Their original name is preserved in the output file.

• Section header string table is properly populated with section names that are actually used. Previously we used to include discarded section names as well.

• Fix the problem when dynamic relocations were propagated to a new section with a name that matched a section in the input binary. E.g., the new .rodata with jump tables had dynamic relocations from the original .rodata.

[maksfb]

Address comments by Rafael.

[rafauler]

LGTM with comments

bolt/lib/Core/BinaryContext.cpp

2033

Flagging in case you want to stick to the other format that would write this as "Section (...) ."

bolt/lib/Rewrite/RewriteInstance.cpp

3843–3849

Check this loop

[maksfb]

Fix section read-only check. Remove mapExtraSections().

[treapster]

I'm a bit concerned about adding OrgSecPrefix to EFMM. My understanding is that now it's impossible or really hard to rewrite a section in-place, because EFMM will automatically duplicate it and add prefix to the original section. I'm developing a patch to rewrite the entire binary and i'm now struggling to rebase it on top of this. I would appreciate clarifications regarding EFMM changes and how to update sections in-place with this code.

[maksfb]

In D135494#3868155, @treapster wrote:

I'm a bit concerned about adding OrgSecPrefix to EFMM. My understanding is that now it's impossible or really hard to rewrite a section in-place, because EFMM will automatically duplicate it and add prefix to the original section. I'm developing a patch to rewrite the entire binary and i'm now struggling to rebase it on top of this. I would appreciate clarifications regarding EFMM changes and how to update sections in-place with this code.

With this change, many sections are still updated in-place, e.g. ".rodata" and every section with code pointers. "-use-old-text" also will rewrite code at the original location.

If the change you are working on relocates every single section at a new location, while reusing space in the original binary, perhaps you need to deregister all original sections?

[treapster]

@maksfb, it doesn't seem like we should deregister updated sections. We don't deregister .init_array or .rodata. My understanding of current logic is that when you emit a section with orgSecPrefix, EFMM will update the original section, and when you emit with original name, EFMM creates a new section and renames the old. Aside from a slight confusion, it causes troubles updating .text section, because you cannot simply emit .text with prefix the same way we do with data sections, so we always get a new BinarySection instance while we need to update the old. When we have two instances, we can't deregister old .text section since a lot of stuff depends on it. So it looks like at least for .text we'll be better off calling BC.registerOrUpdateSection() in EFMM without extra name management. But if we dive further in binary rewriting, similar issues arise with eh frames, and in that case i think it's more reasonable to keep all that renaming/duplicating stuff in RewriteInstance/BinaryEmitter since we may decide different strategy depending on the options.

[maksfb]

@treapster, could you post a detailed description of your plans (or an RFC) to discourse? It’s possible I’m missing details of what you are planning to do.

[treapster]

@maksfb a patch is now not mature enough for RFC, but the idea is that we add more relocations including data-to-data, create them for plt, and emit all these sections with original names and call registerOrUpdate for each in EFMM. If we want to duplicate some section like .rodata, we can rename it to ".bolt.org.rodata" before emitting or emit it under a new name. In my original patch i used the latter, but for compatibility, i think renaming before emission should work. So, the general idea is that instead of this sorcery in EFMM we can call something like RenameDuplicatedSections() prior to emission(in RewriteInstance), where we decide based on options which sections we want rewritten and which duplicated, and then just emit everything under original name. Do you think it's a good idea? Or it won't work?

[maksfb]

In D135494#3887977, @treapster wrote:

@maksfb a patch is now not mature enough for RFC, but the idea is that we add more relocations including data-to-data, create them for plt, and emit all these sections with original names and call registerOrUpdate for each in EFMM. If we want to duplicate some section like .rodata, we can rename it to ".bolt.org.rodata" before emitting or emit it under a new name. In my original patch i used the latter, but for compatibility, i think renaming before emission should work. So, the general idea is that instead of this sorcery in EFMM we can call something like RenameDuplicatedSections() prior to emission(in RewriteInstance), where we decide based on options which sections we want rewritten and which duplicated, and then just emit everything under original name. Do you think it's a good idea? Or it won't work?

@treapster, to be clear, you don't need a patch to submit an RFC, we can have a discussion even before any code is produced. Having this discussion on discourse.llvm.org has other benefits.

BOLT has a special handling for input file sections because it tries to be as noninvasive as possible. The renaming that takes place in EFMM is happening b/c we don't have full control over what sections are emitted by MC layer. E.g., the new ".eh_frame" will be emitted by MC under ".eh_frame" name using special directives while emitting regular code. To avoid a conflict with the original ".eh_frame", EFMM uses prefixes. If you intent to update the original ".eh_frame", assuming the size hasn't increased, you can still do so, but you have to use a special prefix (OrgSecPrefix) while emitting it manually. That's how we handle in-place updates of ".data", ".rodata" etc.

If you are doing a full binary rewrite, you don't have to preserve the original section contents and location. I assume, you have full control over section size and placement too. You can create copies of input file sections, and then deregister the originals since you wouldn't need them while writing out the file. If the input file sections are removed from the list of sections, no renaming will take place inside EFMM.

For the patch, if possible, break it down to multiple small changes. E.g. I suspect you will have to handle more relocation types in BOLT, and that change could be fairly independent.

bolt/include/bolt/Core/BinaryContext.h

class BinaryContext {
   using AddressToSectionMapType = std::multimap<uint64_t, BinarySection *>;
   AddressToSectionMapType AddressToSection;
 
   /// multimap of section name to BinarySection object.  Some binaries
   /// have multiple sections with the same name.
   using NameToSectionMapType = std::multimap<std::string, BinarySection *>;
   NameToSectionMapType NameToSection;
 
+  /// Map section references to BinarySection for matching sections in the
+  /// input file to internal section representation.
+  DenseMap<SectionRef, BinarySection *> SectionRefToBinarySection;
+
   /// Low level section registration.
   BinarySection &registerSection(BinarySection *Section);
 
   /// Store all functions in the binary, sorted by original address.
   std::map<uint64_t, BinaryFunction> BinaryFunctions;
 
   /// A mutex that is used to control parallel accesses to BinaryFunctions
   mutable std::shared_timed_mutex BinaryFunctionsMutex;
class BinaryContext {
   bool ContainsDwarfLegacy{false};
 
   /// Preprocess DWO debug information.
   void preprocessDWODebugInfo();
 
   /// DWARF line info for CUs.
   std::map<unsigned, DwarfLineTable> DwarfLineTablesCUMap;
 
+  /// Internal helper for removing section name from a lookup table.
+  void deregisterSectionName(const BinarySection &Section);
+
 public:
   static Expected<std::unique_ptr<BinaryContext>>
   createBinaryContext(const ObjectFile *File, bool IsPIC,
                       std::unique_ptr<DWARFContext> DwCtx);
 
   /// Superset of compiler units that will contain overwritten code that needs
   /// new debug info. In a few cases, functions may end up not being
   /// overwritten, but it is okay to re-generate debug info for them.
public:
   /// Print the global symbol table.
   void printGlobalSymbols(raw_ostream &OS) const;
 
   /// Register information about the given \p Section so we can look up
   /// sections by address.
   BinarySection &registerSection(SectionRef Section);
 
   /// Register a copy of /p OriginalSection under a different name.
-  BinarySection &registerSection(StringRef SectionName,
+  BinarySection &registerSection(const Twine &SectionName,
                                  const BinarySection &OriginalSection);
 
   /// Register or update the information for the section with the given
   /// /p Name.  If the section already exists, the information in the
   /// section will be updated with the new data.
-  BinarySection &registerOrUpdateSection(StringRef Name, unsigned ELFType,
+  BinarySection &registerOrUpdateSection(const Twine &Name, unsigned ELFType,
                                          unsigned ELFFlags,
                                          uint8_t *Data = nullptr,
                                          uint64_t Size = 0,
                                          unsigned Alignment = 1);
 
   /// Register the information for the note (non-allocatable) section
   /// with the given /p Name.  If the section already exists, the
   /// information in the section will be updated with the new data.
   BinarySection &
-  registerOrUpdateNoteSection(StringRef Name, uint8_t *Data = nullptr,
+  registerOrUpdateNoteSection(const Twine &Name, uint8_t *Data = nullptr,
                               uint64_t Size = 0, unsigned Alignment = 1,
                               bool IsReadOnly = true,
                               unsigned ELFType = ELF::SHT_PROGBITS) {
     return registerOrUpdateSection(Name, ELFType,
                                    BinarySection::getFlags(IsReadOnly), Data,
                                    Size, Alignment);
   }
 
+  /// Remove sections that were preregistered but never used.
+  void deregisterUnusedSections();
+
   /// Remove the given /p Section from the set of all sections.  Return
   /// true if the section was removed (and deleted), otherwise false.
   bool deregisterSection(BinarySection &Section);
 
+  /// Re-register \p Section under the \p NewName.
+  void renameSection(BinarySection &Section, const Twine &NewName);
+
   /// Iterate over all registered sections.
   iterator_range<FilteredSectionIterator> sections() {
     auto notNull = [](const SectionIterator &Itr) { return (bool)*Itr; };
     return make_range(
         FilteredSectionIterator(notNull, Sections.begin(), Sections.end()),
         FilteredSectionIterator(notNull, Sections.end(), Sections.end()));
   }
 
public:
   /// Return largest section containing the given \p Address.  These
   /// functions only work for allocatable sections, i.e. ones with non-zero
   /// addresses.
   ErrorOr<BinarySection &> getSectionForAddress(uint64_t Address);
   ErrorOr<const BinarySection &> getSectionForAddress(uint64_t Address) const {
     return const_cast<BinaryContext *>(this)->getSectionForAddress(Address);
   }
 
+  /// Return internal section representation for a section in a file.
+  BinarySection *getSectionForSectionRef(SectionRef Section) const {
+    return SectionRefToBinarySection.lookup(Section);
+  }
+
   /// Return section(s) associated with given \p Name.
   iterator_range<NameToSectionMapType::iterator>
-  getSectionByName(StringRef Name) {
-    return make_range(NameToSection.equal_range(std::string(Name)));
+  getSectionByName(const Twine &Name) {
+    return make_range(NameToSection.equal_range(Name.str()));
   }
   iterator_range<NameToSectionMapType::const_iterator>
-  getSectionByName(StringRef Name) const {
-    return make_range(NameToSection.equal_range(std::string(Name)));
+  getSectionByName(const Twine &Name) const {
+    return make_range(NameToSection.equal_range(Name.str()));
   }
 
   /// Return the unique section associated with given \p Name.
   /// If there is more than one section with the same name, return an error
   /// object.
-  ErrorOr<BinarySection &> getUniqueSectionByName(StringRef SectionName) const {
+  ErrorOr<BinarySection &>
+  getUniqueSectionByName(const Twine &SectionName) const {
     auto Sections = getSectionByName(SectionName);
     if (Sections.begin() != Sections.end() &&
         std::next(Sections.begin()) == Sections.end())
       return *Sections.begin()->second;
     return std::make_error_code(std::errc::bad_address);
   }
 
   /// Return an unsigned value of \p Size stored at \p Address. The address has

bolt/include/bolt/Core/BinarySection.h

 class BinarySection {
   friend class BinaryContext;
 
   /// Count the number of sections created.
   static uint64_t Count;
 
   BinaryContext &BC;           // Owning BinaryContext
   std::string Name;            // Section name
-  const SectionRef Section;    // SectionRef (may be null)
+  const SectionRef Section;    // SectionRef for input binary sections.
   StringRef Contents;          // Input section contents
   const uint64_t Address;      // Address of section in input binary (may be 0)
   const uint64_t Size;         // Input section size
   uint64_t InputFileOffset{0}; // Offset in the input binary
   unsigned Alignment;          // alignment in bytes (must be > 0)
   unsigned ELFType;            // ELF section type
   unsigned ELFFlags;           // ELF section flags
 
void update(uint8_t *NewData, uint64_t NewSize, unsigned NewAlignment,
     OutputSize = NewSize;
     OutputContents = StringRef(reinterpret_cast<const char *>(NewData),
                                NewData ? NewSize : 0);
     IsFinalized = true;
   }
 
 public:
   /// Copy a section.
-  explicit BinarySection(BinaryContext &BC, StringRef Name,
+  explicit BinarySection(BinaryContext &BC, const Twine &Name,
                          const BinarySection &Section)
-      : BC(BC), Name(Name), Section(Section.getSectionRef()),
+      : BC(BC), Name(Name.str()), Section(SectionRef()),
         Contents(Section.getContents()), Address(Section.getAddress()),
         Size(Section.getSize()), Alignment(Section.getAlignment()),
         ELFType(Section.getELFType()), ELFFlags(Section.getELFFlags()),
         Relocations(Section.Relocations),
-        PendingRelocations(Section.PendingRelocations), OutputName(Name),
+        PendingRelocations(Section.PendingRelocations), OutputName(Name.str()),
         SectionNumber(++Count) {}
 
   BinarySection(BinaryContext &BC, SectionRef Section)
       : BC(BC), Name(getName(Section)), Section(Section),
         Contents(getContents(Section)), Address(Section.getAddress()),
         Size(Section.getSize()), Alignment(Section.getAlignment()),
         OutputName(Name), SectionNumber(++Count) {
     if (isELF()) {
       ELFType = ELFSectionRef(Section).getType();
       ELFFlags = ELFSectionRef(Section).getFlags();
       InputFileOffset = ELFSectionRef(Section).getOffset();
     } else if (isMachO()) {
       auto *O = cast<MachOObjectFile>(Section.getObject());
       InputFileOffset =
           O->is64Bit() ? O->getSection64(Section.getRawDataRefImpl()).offset
                        : O->getSection(Section.getRawDataRefImpl()).offset;
     }
   }
 
   // TODO: pass Data as StringRef/ArrayRef? use StringRef::copy method.
-  BinarySection(BinaryContext &BC, StringRef Name, uint8_t *Data, uint64_t Size,
-                unsigned Alignment, unsigned ELFType, unsigned ELFFlags)
-      : BC(BC), Name(Name),
+  BinarySection(BinaryContext &BC, const Twine &Name, uint8_t *Data,
+                uint64_t Size, unsigned Alignment, unsigned ELFType,
+                unsigned ELFFlags)
+      : BC(BC), Name(Name.str()),
         Contents(reinterpret_cast<const char *>(Data), Data ? Size : 0),
         Address(0), Size(Size), Alignment(Alignment), ELFType(ELFType),
-        ELFFlags(ELFFlags), IsFinalized(true), OutputName(Name),
+        ELFFlags(ELFFlags), IsFinalized(true), OutputName(Name.str()),
         OutputSize(Size), OutputContents(Contents), SectionNumber(++Count) {
     assert(Alignment > 0 && "section alignment must be > 0");
   }
 
   ~BinarySection();
 
   /// Helper function to generate the proper ELF flags from section properties.
   static unsigned getFlags(bool IsReadOnly = true, bool IsText = false,
bool operator<(const BinarySection &Other) const {
     if (isAllocatable() != Other.isAllocatable())
       return isAllocatable() > Other.isAllocatable();
 
     // Input sections take precedence.
     if (hasSectionRef() != Other.hasSectionRef())
       return hasSectionRef() > Other.hasSectionRef();
 
     // Compare allocatable input sections by their address.
-    if (getAddress() != Other.getAddress())
+    if (hasSectionRef() && getAddress() != Other.getAddress())
       return getAddress() < Other.getAddress();
-    if (getAddress() && getSize() != Other.getSize())
+    if (hasSectionRef() && getAddress() && getSize() != Other.getSize())
       return getSize() < Other.getSize();
 
     // Code before data.
     if (isText() != Other.isText())
       return isText() > Other.isText();
 
     // Read-only before writable.
     if (isReadOnly() != Other.isReadOnly())
public:
   }
   uint64_t getOutputAddress() const { return OutputAddress; }
   uint64_t getOutputFileOffset() const { return OutputFileOffset; }
   unsigned getSectionID() const {
     assert(hasValidSectionID() && "trying to use uninitialized section id");
     return SectionID;
   }
   bool hasValidSectionID() const { return SectionID != -1u; }
+  bool hasValidIndex() { return Index != 0; }
   uint32_t getIndex() const { return Index; }
 
   // mutation
   void setOutputAddress(uint64_t Address) { OutputAddress = Address; }
   void setOutputFileOffset(uint64_t Offset) { OutputFileOffset = Offset; }
   void setSectionID(unsigned ID) {
     assert(!hasValidSectionID() && "trying to set section id twice");
     SectionID = ID;
   }
   void setIndex(uint32_t I) { Index = I; }
-  void setOutputName(StringRef Name) { OutputName = std::string(Name); }
+  void setOutputName(const Twine &Name) { OutputName = Name.str(); }
   void setAnonymous(bool Flag) { IsAnonymous = Flag; }
 
-  /// Emit the section as data, possibly with relocations. Use name \p NewName
-  //  for the section during emission if non-empty.
-  void emitAsData(MCStreamer &Streamer, StringRef NewName = StringRef()) const;
+  /// Emit the section as data, possibly with relocations.
+  /// Use name \p SectionName for the section during the emission.
+  void emitAsData(MCStreamer &Streamer, const Twine &SectionName) const;
 
   using SymbolResolverFuncTy = llvm::function_ref<uint64_t(const MCSymbol *)>;
 
   /// Flush all pending relocations to patch original contents of sections
   /// that were not emitted via MCStreamer.
   void flushPendingRelocations(raw_pwrite_stream &OS,
                                SymbolResolverFuncTy Resolver);
 
+  /// Change contents of the section.
+  void updateContents(const uint8_t *Data, size_t NewSize) {
+    OutputContents = StringRef(reinterpret_cast<const char *>(Data), NewSize);
+    OutputSize = NewSize;
+    IsFinalized = true;
+  }
+
   /// Reorder the contents of this section according to /p Order.  If
   /// /p Inplace is true, the entire contents of the section is reordered,
   /// otherwise the new contents contain only the reordered data.
   void reorderContents(const std::vector<BinaryData *> &Order, bool Inplace);
 
   void print(raw_ostream &OS) const;
 
   /// Write the contents of an ELF note section given the name of the producer,

bolt/include/bolt/Rewrite/ExecutableFileMemoryManager.h

private:
 
   struct AllocInfo {
     uint8_t *Address;
     size_t Size;
     size_t Alignment;
   };
   SmallVector<AllocInfo, 8> AllocatedSections;
 
+  // All new sections will be identified by the following prefix.
+  std::string NewSecPrefix;
+
+  // Name prefix used for sections from the input.
+  std::string OrgSecPrefix;
+
 public:
   // Our linker's main purpose is to handle a single object file, created
   // by RewriteInstance after reading the input binary and reordering it.
   // After objects finish loading, we increment this. Therefore, whenever
   // this is greater than zero, we are dealing with additional objects that
   // will not be managed by BinaryContext but only exist to support linking
   // user-supplied objects into the main input executable.
   uint32_t ObjectsLoaded{0};
bool finalizeMemory(std::string *ErrMsg) override {
     ++ObjectsLoaded;
     return false;
   }
 
   /// Ignore EH frames.
   void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr,
                         size_t Size) override {}
   void deregisterEHFrames() override {}
+
+  /// Section name management.
+  void setNewSecPrefix(StringRef Prefix) { NewSecPrefix = Prefix; }
+  void setOrgSecPrefix(StringRef Prefix) { OrgSecPrefix = Prefix; }
 };
 
 } // namespace bolt
 } // namespace llvm
 
 #endif

bolt/include/bolt/Rewrite/MachORewriteInstance.h

class MachORewriteInstance {
 
   std::unique_ptr<ToolOutputFile> Out;
 
   std::unique_ptr<ProfileReaderBase> ProfileReader;
   void preprocessProfileData();
   void processProfileDataPreCFG();
   void processProfileData();
 
+  static StringRef getNewSecPrefix() { return ".bolt.new"; }
   static StringRef getOrgSecPrefix() { return ".bolt.org"; }
 
   void mapInstrumentationSection(StringRef SectionName);
   void mapCodeSections();
 
   void adjustCommandLineOptions();
   void readSpecialSections();
   void discoverFileObjects();

bolt/include/bolt/Rewrite/RewriteInstance.h

private:
   /// BinaryFunction object, preparing all information necessary for binary
   /// optimization.
   void disassembleFunctions();
 
   void buildFunctionsCFG();
 
   void postProcessFunctions();
 
+  void preregisterSections();
+
   /// Run optimizations that operate at the binary, or post-linker, level.
   void runOptimizationPasses();
 
   /// Write code and data into an intermediary object file, map virtual to real
   /// addresses and link the object file, resolving all relocations and
   /// performing final relaxation.
   void emitAndLink();
 
private:
 
   /// Encode MCDecodedPseudoProbe.
   void encodePseudoProbes();
 
   /// Return the list of code sections in the output order.
   std::vector<BinarySection *> getCodeSections();
 
   /// Map all sections to their final addresses.
-  void mapCodeSections(RuntimeDyld &RTDyld);
-  void mapDataSections(RuntimeDyld &RTDyld);
   void mapFileSections(RuntimeDyld &RTDyld);
-  void mapExtraSections(RuntimeDyld &RTDyld);
+
+  /// Map code sections generated by BOLT.
+  void mapCodeSections(RuntimeDyld &RTDyld);
+
+  /// Map the rest of allocatable sections.
+  void mapAllocatableSections(RuntimeDyld &RTDyld);
 
   /// Update output object's values based on the final \p Layout.
   void updateOutputValues(const MCAsmLayout &Layout);
 
   /// Rewrite back all functions (hopefully optimized) that fit in the original
   /// memory footprint for that function. If the function is now larger and does
   /// not fit in the binary, reject it and preserve the original version of the
   /// function. If we couldn't understand the function for some reason in
#define ELF_FUNCTION(TYPE, FUNC)                                               \
   ELF_FUNCTION(void, patchELFGOT);
 
   /// Patch allocatable relocation sections.
   ELF_FUNCTION(void, patchELFAllocatableRelaSections);
 
   /// Finalize memory image of section header string table.
   ELF_FUNCTION(void, finalizeSectionStringTable);
 
-  /// Return a name of the input file section in the output file.
-  template <typename ELFObjType, typename ELFShdrTy>
-  std::string getOutputSectionName(const ELFObjType &Obj,
-                                   const ELFShdrTy &Section);
-
   /// Return a list of all sections to include in the output binary.
   /// Populate \p NewSectionIndex with a map of input to output indices.
   template <typename ELFT>
   std::vector<typename object::ELFObjectFile<ELFT>::Elf_Shdr>
   getOutputSections(object::ELFObjectFile<ELFT> *File,
                     std::vector<uint32_t> &NewSectionIndex);
 
   /// Return true if \p Section should be stripped from the output binary.
private:
 
   static const char TimerGroupName[];
 
   static const char TimerGroupDesc[];
 
   /// Alignment value used for .eh_frame_hdr.
   static constexpr uint64_t EHFrameHdrAlign = 4;
 
+  /// Sections created by BOLT will have an internal name that starts with the
+  /// following prefix. Note that the prefix is used for a section lookup
+  /// internally and the section name in the output might be different.
+  static StringRef getNewSecPrefix() { return ".bolt.new"; }
+
   /// String to be added before the original section name.
   ///
   /// When BOLT creates a new section with the same name as the one in the
   /// input file, it may need to preserve the original section. This prefix
   /// will be added to the name of the original section.
   static StringRef getOrgSecPrefix() { return ".bolt.org"; }
 
-  /// Section name used for new code.
+  /// Section name used for extra BOLT code in addition to .text.
   static StringRef getBOLTTextSectionName() { return ".bolt.text"; }
 
+  /// Common section names.
+  static StringRef getEHFrameSectionName() { return ".eh_frame"; }
+
   /// An instance of the input binary we are processing, externally owned.
   llvm::object::ELFObjectFileBase *InputFile;
 
   /// Command line args used to process binary.
   const int Argc;
   const char *const *Argv;
   StringRef ToolPath;
 
private:
   /// Contains information about pseudo probe description, like its related
   /// function
   ErrorOr<BinarySection &> PseudoProbeDescSection{std::errc::bad_address};
 
   /// .pseudo_probe section.
   /// Contains information about pseudo probe details, like its address
   ErrorOr<BinarySection &> PseudoProbeSection{std::errc::bad_address};
 
+  /// Helper for accessing sections by name.
+  BinarySection *getSection(const Twine &Name) {
+    ErrorOr<BinarySection &> ErrOrSection = BC->getUniqueSectionByName(Name);
+    return ErrOrSection ? &ErrOrSection.get() : nullptr;
+  }
+
   /// A reference to the build-id bytes in the original binary
   StringRef BuildID;
 
   /// Keep track of functions we fail to write in the binary. We need to avoid
   /// rewriting CFI info for these functions.
   std::vector<uint64_t> FailedAddresses;
 
   /// Keep track of which functions didn't fit in their original space in the
   /// last emission, so that we may either decide to split or not optimize them.
   std::set<uint64_t> LargeFunctions;
 
   /// Section header string table.
   StringTableBuilder SHStrTab;
-  std::vector<std::string> SHStrTabPool;
 
   /// A rewrite of strtab
   std::string NewStrTab;
 
   /// Number of processed to data relocations.  Used to implement the
   /// -max-relocations debugging option.
   uint64_t NumDataRelocations{0};
 

bolt/lib/Core/BinaryContext.cpp

BinarySection &BinaryContext::registerSection(BinarySection *Section) {
   (void)Res;
   assert(Res.second && "can't register the same section twice.");
 
   // Only register allocatable sections in the AddressToSection map.
   if (Section->isAllocatable() && Section->getAddress())
     AddressToSection.insert(std::make_pair(Section->getAddress(), Section));
   NameToSection.insert(
       std::make_pair(std::string(Section->getName()), Section));
+  if (Section->hasSectionRef())
+    SectionRefToBinarySection.insert(
+        std::make_pair(Section->getSectionRef(), Section));
+
   LLVM_DEBUG(dbgs() << "BOLT-DEBUG: registering " << *Section << "\n");
   return *Section;
 }
 
 BinarySection &BinaryContext::registerSection(SectionRef Section) {
   return registerSection(new BinarySection(*this, Section));
 }
 
 BinarySection &
-BinaryContext::registerSection(StringRef SectionName,
+BinaryContext::registerSection(const Twine &SectionName,
                                const BinarySection &OriginalSection) {
   return registerSection(
       new BinarySection(*this, SectionName, OriginalSection));
 }
 
 BinarySection &
-BinaryContext::registerOrUpdateSection(StringRef Name, unsigned ELFType,
+BinaryContext::registerOrUpdateSection(const Twine &Name, unsigned ELFType,
                                        unsigned ELFFlags, uint8_t *Data,
                                        uint64_t Size, unsigned Alignment) {
   auto NamedSections = getSectionByName(Name);
   if (NamedSections.begin() != NamedSections.end()) {
     assert(std::next(NamedSections.begin()) == NamedSections.end() &&
            "can only update unique sections");
     BinarySection *Section = NamedSections.begin()->second;
 
     LLVM_DEBUG(dbgs() << "BOLT-DEBUG: updating " << *Section << " -> ");
     const bool Flag = Section->isAllocatable();
     (void)Flag;
     Section->update(Data, Size, Alignment, ELFType, ELFFlags);
     LLVM_DEBUG(dbgs() << *Section << "\n");
     // FIXME: Fix section flags/attributes for MachO.
     if (isELF())
       assert(Flag == Section->isAllocatable() &&
              "can't change section allocation status");
     return *Section;
   }
 
   return registerSection(
       new BinarySection(*this, Name, Data, Size, Alignment, ELFType, ELFFlags));
 }
 
+void BinaryContext::deregisterSectionName(const BinarySection &Section) {
+  auto NameRange = NameToSection.equal_range(Section.getName().str());
+  while (NameRange.first != NameRange.second) {
+    if (NameRange.first->second == &Section) {
+      NameToSection.erase(NameRange.first);
+      break;
+    }
+    ++NameRange.first;
+  }
+}
+
+void BinaryContext::deregisterUnusedSections() {
+  ErrorOr<BinarySection &> AbsSection = getUniqueSectionByName("<absolute>");
+  for (auto SI = Sections.begin(); SI != Sections.end();) {
+    BinarySection *Section = *SI;
+    if (Section->hasSectionRef() || Section->getOutputSize() ||
+        (AbsSection && Section == &AbsSection.get())) {
+      ++SI;
+      continue;
+    }
+
+    LLVM_DEBUG(dbgs() << "LLVM-DEBUG: deregistering " << Section->getName()
+                      << '\n';);
+    deregisterSectionName(*Section);
+    SI = Sections.erase(SI);
+    delete Section;
+  }
+}
+
 bool BinaryContext::deregisterSection(BinarySection &Section) {
   BinarySection *SectionPtr = &Section;
   auto Itr = Sections.find(SectionPtr);
   if (Itr != Sections.end()) {
     auto Range = AddressToSection.equal_range(SectionPtr->getAddress());
     while (Range.first != Range.second) {
       if (Range.first->second == SectionPtr) {
         AddressToSection.erase(Range.first);
         break;
       }
       ++Range.first;
     }
 
-    auto NameRange =
-        NameToSection.equal_range(std::string(SectionPtr->getName()));
-    while (NameRange.first != NameRange.second) {
-      if (NameRange.first->second == SectionPtr) {
-        NameToSection.erase(NameRange.first);
-        break;
-      }
-      ++NameRange.first;
-    }
-
+    deregisterSectionName(*SectionPtr);
     Sections.erase(Itr);
     delete SectionPtr;
     return true;
   }
   return false;
 }
 
+void BinaryContext::renameSection(BinarySection &Section,
+                                  const Twine &NewName) {
+  auto Itr = Sections.find(&Section);
+  assert(Itr != Sections.end() && "Section must exist to be renamed.");
+  Sections.erase(Itr);
+
+  deregisterSectionName(Section);
+
+  Section.Name = NewName.str();
+  Section.setOutputName(NewName);
+
+  NameToSection.insert(std::make_pair(NewName.str(), &Section));
+
+  // Reinsert with the new name.
+  Sections.insert(&Section);
+}
+
 void BinaryContext::printSections(raw_ostream &OS) const {
   for (BinarySection *const &Section : Sections)
     OS << "BOLT-INFO: " << *Section << "\n";
 }
 
 BinarySection &BinaryContext::absoluteSection() {
   if (ErrorOr<BinarySection &> Section = getUniqueSectionByName("<absolute>"))
     return *Section;

bolt/lib/Core/BinaryEmitter.cpp

if (opts::JumpTables > JTS_SPLIT && !JT.Counts.empty()) {
     Streamer.switchSection(JT.Count > 0 ? HotSection : ColdSection);
     Streamer.emitValueToAlignment(JT.EntrySize);
   }
   MCSymbol *LastLabel = nullptr;
   uint64_t Offset = 0;
   for (MCSymbol *Entry : JT.Entries) {
     auto LI = JT.Labels.find(Offset);
     if (LI != JT.Labels.end()) {
-      LLVM_DEBUG(dbgs() << "BOLT-DEBUG: emitting jump table "
-                        << LI->second->getName()
-                        << " (originally was at address 0x"
-                        << Twine::utohexstr(JT.getAddress() + Offset)
-                        << (Offset ? "as part of larger jump table\n" : "\n"));
+      LLVM_DEBUG({
+        dbgs() << "BOLT-DEBUG: emitting jump table " << LI->second->getName()
+               << (Offset ? ") as part of larger jump table\n" : ")\n");
+      });
       if (!LabelCounts.empty()) {
         LLVM_DEBUG(dbgs() << "BOLT-DEBUG: jump table count: "
                           << LabelCounts[LI->second] << '\n');
         if (LabelCounts[LI->second] > 0)
           Streamer.switchSection(HotSection);
         else
           Streamer.switchSection(ColdSection);
         Streamer.emitValueToAlignment(JT.EntrySize);
for (const std::unique_ptr<DWARFUnit> &CU : BC.DwCtx->compile_units()) {
 
     BC.getDwarfLineTable(CU->getOffset())
         .addRawContents(DebugLineContents.slice(Begin, End));
   }
 }
 
 void BinaryEmitter::emitDataSections(StringRef OrgSecPrefix) {
   for (BinarySection &Section : BC.sections()) {
-    if (!Section.hasRelocations() || !Section.hasSectionRef())
+    if (!Section.hasRelocations())
       continue;
 
-    StringRef SectionName = Section.getName();
-    std::string EmitName = Section.isReordered()
-                               ? std::string(Section.getOutputName())
-                               : OrgSecPrefix.str() + std::string(SectionName);
-    Section.emitAsData(Streamer, EmitName);
+    StringRef Prefix = Section.hasSectionRef() ? OrgSecPrefix : "";
+    Section.emitAsData(Streamer, Prefix + Section.getName());
     Section.clearRelocations();
   }
 }
 
 namespace llvm {
 namespace bolt {
 
 void emitBinaryContext(MCStreamer &Streamer, BinaryContext &BC,

bolt/lib/Core/BinarySection.cpp

BinarySection::hash(const BinaryData &BD,
   Hash = hash_combine(Hash,
                       hash_value(Contents.substr(Offset, EndOffset - Offset)));
 
   Cache[&BD] = Hash;
 
   return Hash;
 }
 
-void BinarySection::emitAsData(MCStreamer &Streamer, StringRef NewName) const {
-  StringRef SectionName = !NewName.empty() ? NewName : getName();
+void BinarySection::emitAsData(MCStreamer &Streamer,
+                               const Twine &SectionName) const {
   StringRef SectionContents = getContents();
   MCSectionELF *ELFSection =
       BC.Ctx->getELFSection(SectionName, getELFType(), getELFFlags());
 
   Streamer.switchSection(ELFSection);
   Streamer.emitValueToAlignment(getAlignment());
 
   if (BC.HasRelocations && opts::HotData && isReordered())

bolt/lib/Passes/ReorderData.cpp

if (opts::PrintReorderedData)
       printOrder(*Section, Order.begin(), SplitPoint);
 
     if (!opts::ReorderInplace || FoundUnmoveable) {
       if (opts::ReorderInplace && FoundUnmoveable)
         outs() << "BOLT-INFO: Found unmoveable symbols in "
                << Section->getName() << " falling back to splitting "
                << "instead of in-place reordering.\n";
 
-      // Copy original section to <section name>.cold.
-      BinarySection &Cold = BC.registerSection(
-          std::string(Section->getName()) + ".cold", *Section);
+      // Rename sections.
+      BinarySection &Hot =
+          BC.registerSection(Section->getName() + ".hot", *Section);
+      Hot.setOutputName(Section->getName());
+      Section->setOutputName(".bolt.org" + Section->getName());
 
       // Reorder contents of original section.
-      setSectionOrder(BC, *Section, Order.begin(), SplitPoint);
+      setSectionOrder(BC, Hot, Order.begin(), SplitPoint);
 
       // This keeps the original data from thinking it has been moved.
       for (std::pair<const uint64_t, BinaryData *> &Entry :
            BC.getBinaryDataForSection(*Section)) {
         if (!Entry.second->isMoved()) {
-          Entry.second->setSection(Cold);
-          Entry.second->setOutputSection(Cold);
+          Entry.second->setSection(*Section);
+          Entry.second->setOutputSection(*Section);
         }
       }
     } else {
       outs() << "BOLT-WARNING: Inplace section reordering not supported yet.\n";
       setSectionOrder(BC, *Section, Order.begin(), Order.end());
     }
   }
 }
 
 } // namespace bolt
 } // namespace llvm

bolt/lib/Rewrite/ExecutableFileMemoryManager.cpp

if (BC.isELF()) {
               SectionName == "__fini" || SectionName == "__setup" ||
               SectionName == "__cstring" || SectionName == "__literal16") &&
              "Unexpected section in the instrumentation library");
       // Sections coming from the instrumentation runtime are prefixed with "I".
       SectionName = ("I" + Twine(SectionName)).toStringRef(Buf);
     }
   }
 
-  BinarySection &Section = BC.registerOrUpdateSection(
-      SectionName, ELF::SHT_PROGBITS,
-      BinarySection::getFlags(IsReadOnly, IsCode, true), Ret, Size, Alignment);
-  Section.setSectionID(SectionID);
-  assert(Section.isAllocatable() &&
-         "verify that allocatable is marked as allocatable");
+  BinarySection *Section = nullptr;
+  if (!OrgSecPrefix.empty() && SectionName.startswith(OrgSecPrefix)) {
+    // Update the original section contents.
+    ErrorOr<BinarySection &> OrgSection =
+        BC.getUniqueSectionByName(SectionName.substr(OrgSecPrefix.length()));
+    assert(OrgSection && OrgSection->isAllocatable() &&
+           "Original section must exist and be allocatable.");
+
+    Section = &OrgSection.get();
+    Section->updateContents(Ret, Size);
+  } else {
+    // If the input contains a section with the section name, rename it in the
+    // output file to avoid the section name conflict and emit the new section
+    // under a unique internal name.
+    ErrorOr<BinarySection &> OrgSection =
+        BC.getUniqueSectionByName(SectionName);
+    bool UsePrefix = false;
+    if (OrgSection && OrgSection->hasSectionRef()) {
+      OrgSection->setOutputName(OrgSecPrefix + SectionName);
+      UsePrefix = true;
+    }
+
+    // Register the new section under a unique name to avoid name collision with
+    // sections in the input file.
+    BinarySection &NewSection = BC.registerOrUpdateSection(
+        UsePrefix ? NewSecPrefix + SectionName : SectionName, ELF::SHT_PROGBITS,
+        BinarySection::getFlags(IsReadOnly, IsCode, true), Ret, Size,
+        Alignment);
+    if (UsePrefix)
+      NewSection.setOutputName(SectionName);
+    Section = &NewSection;
+  }
 
-  LLVM_DEBUG(
-      dbgs() << "BOLT: allocating "
-             << (IsCode ? "code" : (IsReadOnly ? "read-only data" : "data"))
-             << " section : " << SectionName << " with size " << Size
-             << ", alignment " << Alignment << " at " << Ret
-             << ", ID = " << SectionID << "\n");
+  LLVM_DEBUG({
+           << " section : " << Section->getOutputName() << " ("
+           << Section->getName() << ")"
+           << " with size " << Size << ", alignment " << Alignment << " at "
+           << Ret << ", ID = " << SectionID << "\n";
+  });
+
+  Section->setSectionID(SectionID);
+
   return Ret;
 }
 
 ExecutableFileMemoryManager::~ExecutableFileMemoryManager() {
   for (const AllocInfo &AI : AllocatedSections)
     llvm::deallocate_buffer(AI.Address, AI.Size, AI.Alignment);
 }
 
 } // namespace bolt
 
 } // namespace llvm

bolt/lib/Rewrite/MachORewriteInstance.cpp

void MachORewriteInstance::emitAndLink() {
   assert(Obj && "createObjectFile cannot return nullptr");
 
   BOLTSymbolResolver Resolver = BOLTSymbolResolver(*BC);
 
   MCAsmLayout FinalLayout(
       static_cast<MCObjectStreamer *>(Streamer.get())->getAssembler());
 
   BC->EFMM.reset(new ExecutableFileMemoryManager(*BC, /*AllowStubs*/ false));
+  BC->EFMM->setOrgSecPrefix(getOrgSecPrefix());
+  BC->EFMM->setNewSecPrefix(getNewSecPrefix());
 
   RTDyld.reset(new decltype(RTDyld)::element_type(*BC->EFMM, Resolver));
   RTDyld->setProcessAllSections(true);
   RTDyld->loadObject(*Obj);
   if (RTDyld->hasError()) {
     outs() << "BOLT-ERROR: RTDyld failed.\n";
     exit(1);
   }

bolt/lib/Rewrite/RewriteInstance.cpp

Error RewriteInstance::discoverStorage() {
   NamedRegionTimer T("discoverStorage", "discover storage", TimerGroupName,
                      TimerGroupDesc, opts::TimeRewrite);
 
   // Stubs are harmful because RuntimeDyld may try to increase the size of
   // sections accounting for stubs when we need those sections to match the
   // same size seen in the input binary, in case this section is a copy
   // of the original one seen in the binary.
   BC->EFMM.reset(new ExecutableFileMemoryManager(*BC, /*AllowStubs*/ false));
+  BC->EFMM->setNewSecPrefix(getNewSecPrefix());
+  BC->EFMM->setOrgSecPrefix(getOrgSecPrefix());
 
   auto ELF64LEFile = dyn_cast<ELF64LEObjectFile>(InputFile);
   const ELFFile<ELF64LE> &Obj = ELF64LEFile->getELFFile();
 
   BC->StartFunctionAddress = Obj.getHeader().e_entry;
 
   NextAvailableAddress = 0;
   uint64_t NextAvailableOffset = 0;
Error RewriteInstance::run() {
 
   processProfileData();
 
   postProcessFunctions();
 
   if (opts::DiffOnly)
     return Error::success();
 
+  preregisterSections();
+
   runOptimizationPasses();
 
   emitAndLink();
 
   updateMetadata();
 
   if (opts::LinuxKernelMode) {
     errs() << "BOLT-WARNING: not writing the output file for Linux Kernel\n";
if (!Function.getSize() && Function.isSimple()) {
         outs() << "BOLT-INFO: setting size of function " << Function << " to "
                << Function.getMaxSize() << " (was 0)\n";
       Function.setSize(Function.getMaxSize());
     }
   }
 }
 
 void RewriteInstance::relocateEHFrameSection() {
-  assert(EHFrameSection && "non-empty .eh_frame section expected");
+  assert(EHFrameSection && "Non-empty .eh_frame section expected.");
 
+  BinarySection *RelocatedEHFrameSection =
+      getSection(".relocated" + getEHFrameSectionName());
+  assert(RelocatedEHFrameSection &&
+         "Relocated eh_frame section should be preregistered.");
   DWARFDataExtractor DE(EHFrameSection->getContents(),
                         BC->AsmInfo->isLittleEndian(),
                         BC->AsmInfo->getCodePointerSize());
   auto createReloc = [&](uint64_t Value, uint64_t Offset, uint64_t DwarfType) {
     if (DwarfType == dwarf::DW_EH_PE_omit)
       return;
 
     // Only fix references that are relative to other locations.
case dwarf::DW_EH_PE_udata8:
       RelType = Relocation::getPC64();
       Offset -= 8;
       break;
     }
 
     // Create a relocation against an absolute value since the goal is to
     // preserve the contents of the section independent of the new values
     // of referenced symbols.
-    EHFrameSection->addRelocation(Offset, nullptr, RelType, Value);
+    RelocatedEHFrameSection->addRelocation(Offset, nullptr, RelType, Value);
   };
 
   Error E = EHFrameParser::parse(DE, EHFrameSection->getAddress(), createReloc);
   check_error(std::move(E), "failed to patch EH frame");
 }
 
 ArrayRef<uint8_t> RewriteInstance::getLSDAData() {
   return ArrayRef<uint8_t>(LSDASection->getData(),
Error RewriteInstance::readSpecialSections() {
   bool HasDebugInfo = false;
 
   // Process special sections.
   for (const SectionRef &Section : InputFile->sections()) {
     Expected<StringRef> SectionNameOrErr = Section.getName();
     check_error(SectionNameOrErr.takeError(), "cannot get section name");
     StringRef SectionName = *SectionNameOrErr;
 
-    // Only register sections with names.
-    if (!SectionName.empty()) {
-      if (Error E = Section.getContents().takeError())
-        return E;
-      BC->registerSection(Section);
-      LLVM_DEBUG(
-          dbgs() << "BOLT-DEBUG: registering section " << SectionName << " @ 0x"
-                 << Twine::utohexstr(Section.getAddress()) << ":0x"
-                 << Twine::utohexstr(Section.getAddress() + Section.getSize())
-                 << "\n");
-      if (isDebugSection(SectionName))
-        HasDebugInfo = true;
-      if (isKSymtabSection(SectionName))
-        opts::LinuxKernelMode = true;
-    }
-  }
 
   if (HasDebugInfo && !opts::UpdateDebugSections && !opts::AggregateOnly) {
     errs() << "BOLT-WARNING: debug info will be stripped from the binary. "
               "Use -update-debug-sections to keep it.\n";
   }
 
   HasTextRelocations = (bool)BC->getUniqueSectionByName(".rela.text");
   HasSymbolTable = (bool)BC->getUniqueSectionByName(".symtab");
void lookup(const LookupSet &Symbols,
     }
 
     OnResolved(std::move(AllResults));
   }
 };
 
 } // anonymous namespace
 
+void RewriteInstance::preregisterSections() {
+  // Preregister sections before emission to set their order in the output.
+  const unsigned ROFlags = BinarySection::getFlags(/*IsReadOnly*/ true,
+                                                   /*IsText*/ false,
+                                                   /*IsAllocatable*/ true);
+  if (BinarySection *EHFrameSection = getSection(getEHFrameSectionName())) {
+    // New .eh_frame.
+    BC->registerOrUpdateSection(getNewSecPrefix() + getEHFrameSectionName(),
+                                ELF::SHT_PROGBITS, ROFlags);
+    // Fully register a relocatable copy of the original .eh_frame.
+    BC->registerSection(".relocated.eh_frame", *EHFrameSection);
+  }
+  BC->registerOrUpdateSection(getNewSecPrefix() + ".gcc_except_table",
+                              ELF::SHT_PROGBITS, ROFlags);
+  BC->registerOrUpdateSection(getNewSecPrefix() + ".rodata", ELF::SHT_PROGBITS,
+                              ROFlags);
+  BC->registerOrUpdateSection(getNewSecPrefix() + ".rodata.cold",
+                              ELF::SHT_PROGBITS, ROFlags);
+}
+
 void RewriteInstance::emitAndLink() {
   NamedRegionTimer T("emitAndLink", "emit and link", TimerGroupName,
                      TimerGroupDesc, opts::TimeRewrite);
   std::error_code EC;
 
   // This is an object file, which we keep for debugging purposes.
   // Once we decide it's useless, we should create it in memory.
   SmallString<128> OutObjectPath;
void RewriteInstance::emitAndLink() {
   emitBinaryContext(*Streamer, *BC, getOrgSecPrefix());
 
   Streamer->finish();
   if (Streamer->getContext().hadError()) {
     errs() << "BOLT-ERROR: Emission failed.\n";
     exit(1);
   }
 
+  ErrorOr<BinarySection &> TextSection =
+      BC->getUniqueSectionByName(BC->getMainCodeSectionName());
+  if (BC->HasRelocations && TextSection)
+    BC->renameSection(*TextSection, getOrgSecPrefix() + ".text");
+
   //////////////////////////////////////////////////////////////////////////////
   // Assign addresses to new sections.
   //////////////////////////////////////////////////////////////////////////////
 
   // Get output object as ObjectFile.
   std::unique_ptr<MemoryBuffer> ObjectMemBuffer =
       MemoryBuffer::getMemBuffer(BOS->str(), "in-memory object file", false);
   std::unique_ptr<object::ObjectFile> Obj = cantFail(
void RewriteInstance::emitAndLink() {
   // layout. Only do this for the object created by ourselves.
   updateOutputValues(FinalLayout);
 
   if (opts::UpdateDebugSections)
     DebugInfoRewriter->updateLineTableOffsets(FinalLayout);
 
   if (RuntimeLibrary *RtLibrary = BC->getRuntimeLibrary())
     RtLibrary->link(*BC, ToolPath, *RTDyld, [this](RuntimeDyld &R) {
-      this->mapExtraSections(*RTDyld);
+      // Map newly registered sections.
+      this->mapAllocatableSections(*RTDyld);
     });
 
   // Once the code is emitted, we can rename function sections to actual
   // output sections and de-register sections used for emission.
   for (BinaryFunction *Function : BC->getAllBinaryFunctions()) {
     ErrorOr<BinarySection &> Section = Function->getCodeSection();
     if (Section &&
         (Function->getImageAddress() == 0 || Function->getImageSize() == 0))
void RewriteInstance::updateLKMarkers() {
   outs() << "BOLT-INFO: patching linux kernel sections. Total patches per "
             "section are as follows:\n";
   for (const std::pair<const std::string, uint64_t> &KV : PatchCounts)
     outs() << "  Section: " << KV.first << ", patch-counts: " << KV.second
            << '\n';
 }
 
 void RewriteInstance::mapFileSections(RuntimeDyld &RTDyld) {
+  BC->deregisterUnusedSections();
+
+  // If no new .eh_frame was written, remove relocated original .eh_frame.
+  BinarySection *RelocatedEHFrameSection =
+      getSection(".relocated" + getEHFrameSectionName());
+  if (RelocatedEHFrameSection && RelocatedEHFrameSection->hasValidSectionID()) {
+    BinarySection *NewEHFrameSection =
+        getSection(getNewSecPrefix() + getEHFrameSectionName());
+    if (!NewEHFrameSection || !NewEHFrameSection->isFinalized()) {
+      // RTDyld will still have to process relocations for the section, hence
+      // we need to assign it the address that wouldn't result in relocation
+      // processing failure.
+      RTDyld.reassignSectionAddress(RelocatedEHFrameSection->getSectionID(),
+                                    NextAvailableAddress);
+      BC->deregisterSection(*RelocatedEHFrameSection);
+    }
+  }
+
   mapCodeSections(RTDyld);
-  mapDataSections(RTDyld);
+
+  // Map the rest of the sections.
+  mapAllocatableSections(RTDyld);
 }
 
 std::vector<BinarySection *> RewriteInstance::getCodeSections() {
   std::vector<BinarySection *> CodeSections;
   for (BinarySection &Section : BC->textSections())
     if (Section.hasValidSectionID())
       CodeSections.emplace_back(&Section);
 
for (auto &BFI : BC->getBinaryFunctions()) {
 
     // Map jump tables if updating in-place.
     if (opts::JumpTables == JTS_BASIC) {
       for (auto &JTI : Function.JumpTables) {
         JumpTable *JT = JTI.second;
         BinarySection &Section = JT->getOutputSection();
         Section.setOutputAddress(JT->getAddress());
         Section.setOutputFileOffset(getFileOffsetForAddress(JT->getAddress()));
-        LLVM_DEBUG(dbgs() << "BOLT-DEBUG: mapping " << Section.getName()
+        LLVM_DEBUG(dbgs() << "BOLT-DEBUG: mapping JT " << Section.getName()
                           << " to 0x" << Twine::utohexstr(JT->getAddress())
                           << '\n');
         RTDyld.reassignSectionAddress(Section.getSectionID(), JT->getAddress());
       }
     }
 
     if (!Function.isSplit())
       continue;
for (auto &BFI : BC->getBinaryFunctions()) {
     // Cold fragments are aligned at 16 bytes.
     NextAvailableAddress = alignTo(NextAvailableAddress, 16);
     if (TooLarge) {
       // The corresponding FDE will refer to address 0.
       FF.setAddress(0);
       FF.setImageAddress(0);
       FF.setImageSize(0);
       FF.setFileOffset(0);
+      BC->deregisterSection(*ColdSection);
     } else {
       FF.setAddress(NextAvailableAddress);
       FF.setImageAddress(ColdSection->getAllocAddress());
       FF.setImageSize(ColdSection->getOutputSize());
       FF.setFileOffset(getFileOffsetForAddress(NextAvailableAddress));
       ColdSection->setOutputAddress(FF.getAddress());
     }
 
BinarySection &Section =
                                   NewTextSectionSize,
                                   16);
     Section.setOutputAddress(NewTextSectionStartAddress);
     Section.setOutputFileOffset(
         getFileOffsetForAddress(NewTextSectionStartAddress));
   }
 }
 
-void RewriteInstance::mapDataSections(RuntimeDyld &RTDyld) {
-  // Map special sections to their addresses in the output image.
-  // These are the sections that we generate via MCStreamer.
-  // The order is important.
-  std::vector<std::string> Sections = {
-      ".eh_frame", Twine(getOrgSecPrefix(), ".eh_frame").str(),
-      ".gcc_except_table", ".rodata", ".rodata.cold"};
-  if (RuntimeLibrary *RtLibrary = BC->getRuntimeLibrary())
-    RtLibrary->addRuntimeLibSections(Sections);
-
-  if (!EHFrameSection || !EHFrameSection->isFinalized()) {
-    ErrorOr<BinarySection &> OldEHFrameSection =
-        BC->getUniqueSectionByName(Twine(getOrgSecPrefix(), ".eh_frame").str());
-    if (OldEHFrameSection) {
-      RTDyld.reassignSectionAddress(OldEHFrameSection->getSectionID(),
-                                    NextAvailableAddress);
-      BC->deregisterSection(*OldEHFrameSection);
-    }
-  }
-
-  for (std::string &SectionName : Sections) {
-    ErrorOr<BinarySection &> Section = BC->getUniqueSectionByName(SectionName);
-    if (!Section || !Section->isAllocatable() || !Section->isFinalized())
-      continue;
-    NextAvailableAddress =
-        alignTo(NextAvailableAddress, Section->getAlignment());
-    LLVM_DEBUG(dbgs() << "BOLT: mapping section " << SectionName << " (0x"
-                      << Twine::utohexstr(Section->getAllocAddress())
-                      << ") to 0x" << Twine::utohexstr(NextAvailableAddress)
-                      << ":0x"
-                      << Twine::utohexstr(NextAvailableAddress +
-                                          Section->getOutputSize())
-                      << '\n');
-
-    RTDyld.reassignSectionAddress(Section->getSectionID(),
-                                  NextAvailableAddress);
-    Section->setOutputAddress(NextAvailableAddress);
-    Section->setOutputFileOffset(getFileOffsetForAddress(NextAvailableAddress));
-
-    NextAvailableAddress += Section->getOutputSize();
-  }
-
-  // Handling for sections with relocations.
-  for (BinarySection &Section : BC->sections()) {
-    if (!Section.hasSectionRef())
+void RewriteInstance::mapAllocatableSections(RuntimeDyld &RTDyld) {
+  // Allocate read-only sections first, then writable sections.
+  enum : uint8_t { ST_READONLY, ST_READWRITE };
+  for (uint8_t SType = ST_READONLY; SType <= ST_READWRITE; ++SType) {
+    for (BinarySection &Section : BC->allocatableSections()) {
+      if (!Section.hasValidSectionID())
         continue;
 
-    StringRef SectionName = Section.getName();
-    ErrorOr<BinarySection &> OrgSection =
-        BC->getUniqueSectionByName((getOrgSecPrefix() + SectionName).str());
-    if (!OrgSection ||
-        !OrgSection->isAllocatable() ||
-        !OrgSection->isFinalized() ||
-        !OrgSection->hasValidSectionID())
+      if (Section.isReadOnly() != (SType == ST_READONLY))
         continue;
 
-    if (OrgSection->getOutputAddress()) {
-      LLVM_DEBUG(dbgs() << "BOLT-DEBUG: section " << SectionName
-                        << " is already mapped at 0x"
-                        << Twine::utohexstr(OrgSection->getOutputAddress())
-                        << '\n');
+      if (Section.getOutputAddress()) {
+        LLVM_DEBUG({
+          dbgs() << "BOLT-DEBUG: section " << Section.getName()
+                 << Twine::utohexstr(Section.getOutputAddress()) << '\n';
+        });
         continue;
       }
-    LLVM_DEBUG(
-        dbgs() << "BOLT: mapping original section " << SectionName << " (0x"
-               << Twine::utohexstr(OrgSection->getAllocAddress()) << ") to 0x"
-               << Twine::utohexstr(Section.getAddress()) << '\n');
 
-    RTDyld.reassignSectionAddress(OrgSection->getSectionID(),
+      if (Section.hasSectionRef()) {
+        LLVM_DEBUG({
+          dbgs() << "BOLT-DEBUG: mapping original section " << Section.getName()
+                 << " to 0x" << Twine::utohexstr(Section.getAddress()) << '\n';
+        });
+        Section.setOutputAddress(Section.getAddress());
+        Section.setOutputFileOffset(Section.getInputFileOffset());
+        RTDyld.reassignSectionAddress(Section.getSectionID(),
                                       Section.getAddress());
-
-    OrgSection->setOutputAddress(Section.getAddress());
-    OrgSection->setOutputFileOffset(Section.getContents().data() -
-                                    InputFile->getData().data());
-  }
-}
-
-void RewriteInstance::mapExtraSections(RuntimeDyld &RTDyld) {
-  for (BinarySection &Section : BC->allocatableSections()) {
-    if (Section.getOutputAddress() || !Section.hasValidSectionID())
-      continue;
+      } else {
         NextAvailableAddress =
             alignTo(NextAvailableAddress, Section.getAlignment());
-    Section.setOutputAddress(NextAvailableAddress);
-    NextAvailableAddress += Section.getOutputSize();
-
-    LLVM_DEBUG(dbgs() << "BOLT: (extra) mapping " << Section.getName()
-                      << " at 0x" << Twine::utohexstr(Section.getAllocAddress())
-                      << " to 0x"
-                      << Twine::utohexstr(Section.getOutputAddress()) << '\n');
+        LLVM_DEBUG({
+          dbgs() << "BOLT: mapping section " << Section.getName() << " (0x"
+                 << Twine::utohexstr(Section.getAllocAddress()) << ") to 0x"
+                 << Twine::utohexstr(NextAvailableAddress) << ":0x"
+                 << Twine::utohexstr(NextAvailableAddress +
+                                     Section.getOutputSize())
+                 << '\n';
+        });
 
         RTDyld.reassignSectionAddress(Section.getSectionID(),
-                                  Section.getOutputAddress());
+                                      NextAvailableAddress);
+        Section.setOutputAddress(NextAvailableAddress);
         Section.setOutputFileOffset(
-        getFileOffsetForAddress(Section.getOutputAddress()));
+            getFileOffsetForAddress(NextAvailableAddress));
+
+        NextAvailableAddress += Section.getOutputSize();
+      }
+    }
   }
 }
 
 void RewriteInstance::updateOutputValues(const MCAsmLayout &Layout) {
   for (BinaryFunction *Function : BC->getAllBinaryFunctions())
     Function->updateOutputValues(Layout);
 }
 
for (const ELF64LE::Phdr &Phdr : cantFail(Obj.program_headers())) {
     if (PHDRTableAddress && Phdr.p_type == ELF::PT_PHDR) {
       NewPhdr.p_offset = PHDRTableOffset;
       NewPhdr.p_vaddr = PHDRTableAddress;
       NewPhdr.p_paddr = PHDRTableAddress;
       NewPhdr.p_filesz = sizeof(NewPhdr) * Phnum;
       NewPhdr.p_memsz = sizeof(NewPhdr) * Phnum;
     } else if (Phdr.p_type == ELF::PT_GNU_EH_FRAME) {
       ErrorOr<BinarySection &> EHFrameHdrSec =
-          BC->getUniqueSectionByName(".eh_frame_hdr");
+          BC->getUniqueSectionByName(getNewSecPrefix() + ".eh_frame_hdr");
       if (EHFrameHdrSec && EHFrameHdrSec->isAllocatable() &&
           EHFrameHdrSec->isFinalized()) {
         NewPhdr.p_offset = EHFrameHdrSec->getOutputFileOffset();
         NewPhdr.p_vaddr = EHFrameHdrSec->getOutputAddress();
         NewPhdr.p_paddr = EHFrameHdrSec->getOutputAddress();
         NewPhdr.p_filesz = EHFrameHdrSec->getOutputSize();
         NewPhdr.p_memsz = EHFrameHdrSec->getOutputSize();
       }
void RewriteInstance::rewriteNoteSections() {
 
   // Copy over non-allocatable section contents and update file offsets.
   for (const ELF64LE::Shdr &Section : cantFail(Obj.sections())) {
     if (Section.sh_type == ELF::SHT_NULL)
       continue;
     if (Section.sh_flags & ELF::SHF_ALLOC)
       continue;
 
+    SectionRef SecRef = ELF64LEFile->toSectionRef(&Section);
+    BinarySection *BSec = BC->getSectionForSectionRef(SecRef);
+    assert(BSec && !BSec->isAllocatable() &&
+           "Matching non-allocatable BinarySection should exist.");
+
     StringRef SectionName =
         cantFail(Obj.getSectionName(Section), "cannot get section name");
-    ErrorOr<BinarySection &> BSec = BC->getUniqueSectionByName(SectionName);
-
     if (shouldStrip(Section, SectionName))
       continue;
 
     // Insert padding as needed.
     NextAvailableOffset =
         appendPadding(OS, NextAvailableOffset, Section.sh_addralign);
 
     // New section size.
     uint64_t Size = 0;
     bool DataWritten = false;
     uint8_t *SectionData = nullptr;
     // Copy over section contents unless it's one of the sections we overwrite.
     if (!willOverwriteSection(SectionName)) {
       Size = Section.sh_size;
       StringRef Dataref = InputFile->getData().substr(Section.sh_offset, Size);
       std::string Data;
-      if (BSec && BSec->getPatcher()) {
+      if (BSec->getPatcher()) {
         Data = BSec->getPatcher()->patchBinary(Dataref);
         Dataref = StringRef(Data);
       }
 
       // Section was expanded, so need to treat it as overwrite.
       if (Size != Dataref.size()) {
-        BSec = BC->registerOrUpdateNoteSection(
+        BSec = &BC->registerOrUpdateNoteSection(
             SectionName, copyByteArray(Dataref), Dataref.size());
         Size = 0;
       } else {
         OS << Dataref;
         DataWritten = true;
 
         // Add padding as the section extension might rely on the alignment.
         Size = appendPadding(OS, Size, Section.sh_addralign);
       }
     }
 
     // Perform section post-processing.
-    if (BSec && !BSec->isAllocatable()) {
-      assert(BSec->getAlignment() <= Section.sh_addralign &&
-             "alignment exceeds value in file");
 
-      if (BSec->getAllocAddress()) {
-        assert(!DataWritten && "Writing section twice.");
-        (void)DataWritten;
-        SectionData = BSec->getOutputData();
 
-        LLVM_DEBUG(dbgs() << "BOLT-DEBUG: " << (Size ? "appending" : "writing")
-                          << " contents to section " << SectionName << '\n');
-        OS.write(reinterpret_cast<char *>(SectionData), BSec->getOutputSize());
-        Size += BSec->getOutputSize();
-      }
 
-      BSec->setOutputFileOffset(NextAvailableOffset);
-      BSec->flushPendingRelocations(OS,
-        [this] (const MCSymbol *S) {
-          return getNewValueForSymbol(S->getName());
-        });
-    }
+    BSec->flushPendingRelocations(OS, [this](const MCSymbol *S) {
 
     // Set/modify section info.
-    BinarySection &NewSection =
-      BC->registerOrUpdateNoteSection(SectionName,
-                                      SectionData,
-                                      Size,
-                                      Section.sh_addralign,
-                                      BSec ? BSec->isReadOnly() : false,
-                                      BSec ? BSec->getELFType()
-                                           : ELF::SHT_PROGBITS);
+    BinarySection &NewSection = BC->registerOrUpdateNoteSection(
+        SectionName, SectionData, Size, Section.sh_addralign,
+        BSec->isReadOnly(), BSec->getELFType());
     NewSection.setOutputAddress(0);
     NewSection.setOutputFileOffset(NextAvailableOffset);
 
     NextAvailableOffset += Size;
   }
 
   // Write new note sections.
   for (BinarySection &Section : BC->nonAllocatableSections()) {
for (BinarySection &Section : BC->nonAllocatableSections()) {
 
     OS.write(Section.getOutputContents().data(), Section.getOutputSize());
     NextAvailableOffset += Section.getOutputSize();
   }
 }
 
 template <typename ELFT>
 void RewriteInstance::finalizeSectionStringTable(ELFObjectFile<ELFT> *File) {
-  using ELFShdrTy = typename ELFT::Shdr;
-  const ELFFile<ELFT> &Obj = File->getELFFile();
-
   // Pre-populate section header string table.
-  for (const ELFShdrTy &Section : cantFail(Obj.sections())) {
-    StringRef SectionName =
-        cantFail(Obj.getSectionName(Section), "cannot get section name");
-    SHStrTab.add(SectionName);
-    std::string OutputSectionName = getOutputSectionName(Obj, Section);
-    if (OutputSectionName != SectionName)
-      SHStrTabPool.emplace_back(std::move(OutputSectionName));
-  }
-  for (const std::string &Str : SHStrTabPool)
-    SHStrTab.add(Str);
   for (const BinarySection &Section : BC->sections())
-    SHStrTab.add(Section.getName());
+    if (!Section.isAnonymous())
+      SHStrTab.add(Section.getOutputName());
   SHStrTab.finalize();
 
   const size_t SHStrTabSize = SHStrTab.getSize();
   uint8_t *DataCopy = new uint8_t[SHStrTabSize];
   memset(DataCopy, 0, SHStrTabSize);
   SHStrTab.write(DataCopy);
   BC->registerOrUpdateNoteSection(".shstrtab",
                                   DataCopy,
void RewriteInstance::encodeBATSection() {
   const std::string BoltInfo =
       BinarySection::encodeELFNote("BOLT", DescStr, BinarySection::NT_BOLT_BAT);
   BC->registerOrUpdateNoteSection(BoltAddressTranslation::SECTION_NAME,
                                   copyByteArray(BoltInfo), BoltInfo.size(),
                                   /*Alignment=*/1,
                                   /*IsReadOnly=*/true, ELF::SHT_NOTE);
 }
 
-template <typename ELFObjType, typename ELFShdrTy>
-std::string RewriteInstance::getOutputSectionName(const ELFObjType &Obj,
-                                                  const ELFShdrTy &Section) {
-  if (Section.sh_type == ELF::SHT_NULL)
-    return "";
-
-  StringRef SectionName =
-      cantFail(Obj.getSectionName(Section), "cannot get section name");
-
-  if ((Section.sh_flags & ELF::SHF_ALLOC) && willOverwriteSection(SectionName))
-    return (getOrgSecPrefix() + SectionName).str();
-
-  return std::string(SectionName);
-}
-
 template <typename ELFShdrTy>
 bool RewriteInstance::shouldStrip(const ELFShdrTy &Section,
                                   StringRef SectionName) {
   // Strip non-allocatable relocation sections.
   if (!(Section.sh_flags & ELF::SHF_ALLOC) && Section.sh_type == ELF::SHT_RELA)
     return true;
 
   // Strip debug sections if not updating them.

 template <typename ELFT>
 std::vector<typename object::ELFObjectFile<ELFT>::Elf_Shdr>
 RewriteInstance::getOutputSections(ELFObjectFile<ELFT> *File,
                                    std::vector<uint32_t> &NewSectionIndex) {
   using ELFShdrTy = typename ELFObjectFile<ELFT>::Elf_Shdr;
   const ELFFile<ELFT> &Obj = File->getELFFile();
   typename ELFT::ShdrRange Sections = cantFail(Obj.sections());
 
-  // Keep track of section header entries together with their name.
-  std::vector<std::pair<std::string, ELFShdrTy>> OutputSections;
-  auto addSection = [&](const std::string &Name, const ELFShdrTy &Section) {
+  // Keep track of section header entries attached to the corresponding section.
+  std::vector<std::pair<BinarySection *, ELFShdrTy>> OutputSections;
+  auto addSection = [&](const ELFShdrTy &Section, BinarySection *BinSec) {
     ELFShdrTy NewSection = Section;
-    NewSection.sh_name = SHStrTab.getOffset(Name);
-    OutputSections.emplace_back(Name, std::move(NewSection));
+    NewSection.sh_name = SHStrTab.getOffset(BinSec->getOutputName());
+    OutputSections.emplace_back(BinSec, std::move(NewSection));
   };
 
   // Copy over entries for original allocatable sections using modified name.
   for (const ELFShdrTy &Section : Sections) {
     // Always ignore this section.
     if (Section.sh_type == ELF::SHT_NULL) {
-      OutputSections.emplace_back("", Section);
+      OutputSections.emplace_back(nullptr, Section);
       continue;
     }
 
     if (!(Section.sh_flags & ELF::SHF_ALLOC))
       continue;
 
-    addSection(getOutputSectionName(Obj, Section), Section);
+    SectionRef SecRef = File->toSectionRef(&Section);
+    BinarySection *BinSec = BC->getSectionForSectionRef(SecRef);
+    assert(BinSec && "Matching BinarySection should exist.");
+
+    addSection(Section, BinSec);
   }
 
-  for (const BinarySection &Section : BC->allocatableSections()) {
+  for (BinarySection &Section : BC->allocatableSections()) {
     if (!Section.isFinalized())
       continue;
 
-    if (Section.getName().startswith(getOrgSecPrefix()) ||
-        Section.isAnonymous()) {
+    if (Section.hasSectionRef() || Section.isAnonymous()) {
       if (opts::Verbosity)
         outs() << "BOLT-INFO: not writing section header for section "
-               << Section.getName() << '\n';
+               << Section.getOutputName() << '\n';
       continue;
     }
 
     if (opts::Verbosity >= 1)
-      outs() << "BOLT-INFO: writing section header for " << Section.getName()
-             << '\n';
+      outs() << "BOLT-INFO: writing section header for "
+             << Section.getOutputName() << '\n';
     ELFShdrTy NewSection;
     NewSection.sh_type = ELF::SHT_PROGBITS;
     NewSection.sh_addr = Section.getOutputAddress();
     NewSection.sh_offset = Section.getOutputFileOffset();
     NewSection.sh_size = Section.getOutputSize();
     NewSection.sh_entsize = 0;
     NewSection.sh_flags = Section.getELFFlags();
     NewSection.sh_link = 0;
     NewSection.sh_info = 0;
     NewSection.sh_addralign = Section.getAlignment();
-    addSection(std::string(Section.getName()), NewSection);
+    addSection(NewSection, &Section);
   }
 
   // Sort all allocatable sections by their offset.
-  llvm::stable_sort(OutputSections,
-                    [](const std::pair<std::string, ELFShdrTy> &A,
-                       const std::pair<std::string, ELFShdrTy> &B) {
-                      return A.second.sh_offset < B.second.sh_offset;
-                    });
+  llvm::stable_sort(OutputSections, [](const auto &A, const auto &B) {
 
   // Fix section sizes to prevent overlapping.
   ELFShdrTy *PrevSection = nullptr;
-  StringRef PrevSectionName;
+  BinarySection *PrevBinSec = nullptr;
   for (auto &SectionKV : OutputSections) {
     ELFShdrTy &Section = SectionKV.second;
 
     // TBSS section does not take file or memory space. Ignore it for layout
     // purposes.
     if (Section.sh_type == ELF::SHT_NOBITS && (Section.sh_flags & ELF::SHF_TLS))
       continue;
 
     if (PrevSection &&
         PrevSection->sh_addr + PrevSection->sh_size > Section.sh_addr) {
       if (opts::Verbosity > 1)
-        outs() << "BOLT-INFO: adjusting size for section " << PrevSectionName
-               << '\n';
+        outs() << "BOLT-INFO: adjusting size for section "
+               << PrevBinSec->getOutputName() << '\n';
       PrevSection->sh_size = Section.sh_addr > PrevSection->sh_addr
                                  ? Section.sh_addr - PrevSection->sh_addr
                                  : 0;
     }
 
     PrevSection = &Section;
-    PrevSectionName = SectionKV.first;
+    PrevBinSec = SectionKV.first;
   }
 
   uint64_t LastFileOffset = 0;
 
   // Copy over entries for non-allocatable sections performing necessary
   // adjustments.
   for (const ELFShdrTy &Section : Sections) {
     if (Section.sh_type == ELF::SHT_NULL)
       continue;
     if (Section.sh_flags & ELF::SHF_ALLOC)
       continue;
 
     StringRef SectionName =
         cantFail(Obj.getSectionName(Section), "cannot get section name");
 
     if (shouldStrip(Section, SectionName))
       continue;
 
-    ErrorOr<BinarySection &> BSec = BC->getUniqueSectionByName(SectionName);
-    assert(BSec && "missing section info for non-allocatable section");
+    SectionRef SecRef = File->toSectionRef(&Section);
+    BinarySection *BinSec = BC->getSectionForSectionRef(SecRef);
+    assert(BinSec && "Matching BinarySection should exist.");
 
     ELFShdrTy NewSection = Section;
-    NewSection.sh_offset = BSec->getOutputFileOffset();
-    NewSection.sh_size = BSec->getOutputSize();
+    NewSection.sh_offset = BinSec->getOutputFileOffset();
+    NewSection.sh_size = BinSec->getOutputSize();
 
     if (NewSection.sh_type == ELF::SHT_SYMTAB)
       NewSection.sh_info = NumLocalSymbols;
 
-    addSection(std::string(SectionName), NewSection);
+    addSection(NewSection, BinSec);
 
-    LastFileOffset = BSec->getOutputFileOffset();
+    LastFileOffset = BinSec->getOutputFileOffset();
   }
 
   // Create entries for new non-allocatable sections.
   for (BinarySection &Section : BC->nonAllocatableSections()) {
     if (Section.getOutputFileOffset() <= LastFileOffset)
       continue;
 
     if (opts::Verbosity >= 1)
-      outs() << "BOLT-INFO: writing section header for " << Section.getName()
-             << '\n';
+      outs() << "BOLT-INFO: writing section header for "
+             << Section.getOutputName() << '\n';
 
     ELFShdrTy NewSection;
     NewSection.sh_type = Section.getELFType();
     NewSection.sh_addr = 0;
     NewSection.sh_offset = Section.getOutputFileOffset();
     NewSection.sh_size = Section.getOutputSize();
     NewSection.sh_entsize = 0;
     NewSection.sh_flags = Section.getELFFlags();
     NewSection.sh_link = 0;
     NewSection.sh_info = 0;
     NewSection.sh_addralign = Section.getAlignment();
 
-    addSection(std::string(Section.getName()), NewSection);
+    addSection(NewSection, &Section);
   }
 
   // Assign indices to sections.
   std::unordered_map<std::string, uint64_t> NameToIndex;
-  for (uint32_t Index = 1; Index < OutputSections.size(); ++Index) {
-    const std::string &SectionName = OutputSections[Index].first;
-    NameToIndex[SectionName] = Index;
-    if (ErrorOr<BinarySection &> Section =
-            BC->getUniqueSectionByName(SectionName))
-      Section->setIndex(Index);
-  }
+  for (uint32_t Index = 1; Index < OutputSections.size(); ++Index)
+    OutputSections[Index].first->setIndex(Index);
 
   // Update section index mapping
   NewSectionIndex.clear();
   NewSectionIndex.resize(Sections.size(), 0);
   for (const ELFShdrTy &Section : Sections) {
     if (Section.sh_type == ELF::SHT_NULL)
       continue;
 
     size_t OrgIndex = std::distance(Sections.begin(), &Section);
-    std::string SectionName = getOutputSectionName(Obj, Section);
+
+    SectionRef SecRef = File->toSectionRef(&Section);
+    BinarySection *BinSec = BC->getSectionForSectionRef(SecRef);
+    assert(BinSec && "BinarySection should exist for an input section.");
 
     // Some sections are stripped
-    if (!NameToIndex.count(SectionName))
+    if (!BinSec->hasValidIndex())
       continue;
 
-    NewSectionIndex[OrgIndex] = NameToIndex[SectionName];
+    NewSectionIndex[OrgIndex] = BinSec->getIndex();
   }
 
   std::vector<ELFShdrTy> SectionsOnly(OutputSections.size());
   llvm::transform(OutputSections, SectionsOnly.begin(),
-                  [](std::pair<std::string, ELFShdrTy> &SectionInfo) {
-                    return SectionInfo.second;
-                  });
+                  [](auto &SectionInfo) { return SectionInfo.second; });
 
   return SectionsOnly;
 }
 
 // Rewrite section header table inserting new entries as needed. The sections
 // header table size itself may affect the offsets of other sections,
 // so we are placing it at the end of the binary.
 //
void RewriteInstance::rewriteFile() {
   }
 
   for (BinarySection &Section : BC->allocatableSections())
     Section.flushPendingRelocations(OS, [this](const MCSymbol *S) {
       return getNewValueForSymbol(S->getName());
     });
 
   // If .eh_frame is present create .eh_frame_hdr.
-  if (EHFrameSection && EHFrameSection->isFinalized())
+  if (EHFrameSection)
     writeEHFrameHeader();
 
   // Add BOLT Addresses Translation maps to allow profile collection to
   // happen in the output binary
   if (opts::EnableBAT)
     addBATSection();
 
   // Patch program header table.
void RewriteInstance::rewriteFile() {
   }
 
   Out->keep();
   EC = sys::fs::setPermissions(opts::OutputFilename, sys::fs::perms::all_all);
   check_error(EC, "cannot set permissions of output file");
 }
 
 void RewriteInstance::writeEHFrameHeader() {
+  BinarySection *NewEHFrameSection =
+      getSection(getNewSecPrefix() + getEHFrameSectionName());
+
+  // No need to update the header if no new .eh_frame was created.
+  if (!NewEHFrameSection)
+    return;
+
   DWARFDebugFrame NewEHFrame(BC->TheTriple->getArch(), true,
-                             EHFrameSection->getOutputAddress());
+                             NewEHFrameSection->getOutputAddress());
   Error E = NewEHFrame.parse(DWARFDataExtractor(
-      EHFrameSection->getOutputContents(), BC->AsmInfo->isLittleEndian(),
+      NewEHFrameSection->getOutputContents(), BC->AsmInfo->isLittleEndian(),
       BC->AsmInfo->getCodePointerSize()));
   check_error(std::move(E), "failed to parse EH frame");
 
-  uint64_t OldEHFrameAddress = 0;
-  StringRef OldEHFrameContents;
-  ErrorOr<BinarySection &> OldEHFrameSection =
-      BC->getUniqueSectionByName(Twine(getOrgSecPrefix(), ".eh_frame").str());
-  if (OldEHFrameSection) {
-    OldEHFrameAddress = OldEHFrameSection->getOutputAddress();
-    OldEHFrameContents = OldEHFrameSection->getOutputContents();
-  }
-  DWARFDebugFrame OldEHFrame(BC->TheTriple->getArch(), true, OldEHFrameAddress);
-  Error Er = OldEHFrame.parse(
-      DWARFDataExtractor(OldEHFrameContents, BC->AsmInfo->isLittleEndian(),
-                         BC->AsmInfo->getCodePointerSize()));
+  uint64_t RelocatedEHFrameAddress = 0;
+  StringRef RelocatedEHFrameContents;
+  BinarySection *RelocatedEHFrameSection =
+      getSection(".relocated" + getEHFrameSectionName());
+  if (RelocatedEHFrameSection) {
+    RelocatedEHFrameAddress = RelocatedEHFrameSection->getOutputAddress();
+    RelocatedEHFrameContents = RelocatedEHFrameSection->getOutputContents();
+  }
+  DWARFDebugFrame RelocatedEHFrame(BC->TheTriple->getArch(), true,
+                                   RelocatedEHFrameAddress);
+  Error Er = RelocatedEHFrame.parse(DWARFDataExtractor(
+      RelocatedEHFrameContents, BC->AsmInfo->isLittleEndian(),
   check_error(std::move(Er), "failed to parse EH frame");
 
   LLVM_DEBUG(dbgs() << "BOLT: writing a new .eh_frame_hdr\n");
 
   NextAvailableAddress =
       appendPadding(Out->os(), NextAvailableAddress, EHFrameHdrAlign);
 
   const uint64_t EHFrameHdrOutputAddress = NextAvailableAddress;
   const uint64_t EHFrameHdrFileOffset =
       getFileOffsetForAddress(NextAvailableAddress);
 
   std::vector<char> NewEHFrameHdr = CFIRdWrt->generateEHFrameHeader(
-      OldEHFrame, NewEHFrame, EHFrameHdrOutputAddress, FailedAddresses);
+      RelocatedEHFrame, NewEHFrame, EHFrameHdrOutputAddress, FailedAddresses);
 
   assert(Out->os().tell() == EHFrameHdrFileOffset && "offset mismatch");
   Out->os().write(NewEHFrameHdr.data(), NewEHFrameHdr.size());
 
   const unsigned Flags = BinarySection::getFlags(/*IsReadOnly=*/true,
                                                  /*IsText=*/false,
                                                  /*IsAllocatable=*/true);
+  BinarySection *OldEHFrameHdrSection = getSection(".eh_frame_hdr");
+  if (OldEHFrameHdrSection)
+    OldEHFrameHdrSection->setOutputName(getOrgSecPrefix() + ".eh_frame_hdr");
+
   BinarySection &EHFrameHdrSec = BC->registerOrUpdateSection(
-      ".eh_frame_hdr", ELF::SHT_PROGBITS, Flags, nullptr, NewEHFrameHdr.size(),
-      /*Alignment=*/1);
+      getNewSecPrefix() + ".eh_frame_hdr", ELF::SHT_PROGBITS, Flags, nullptr,
+      NewEHFrameHdr.size(), /*Alignment=*/1);
   EHFrameHdrSec.setOutputFileOffset(EHFrameHdrFileOffset);
   EHFrameHdrSec.setOutputAddress(EHFrameHdrOutputAddress);
+  EHFrameHdrSec.setOutputName(".eh_frame_hdr");
 
   NextAvailableAddress += EHFrameHdrSec.getOutputSize();
 
-  // Merge new .eh_frame with original so that gdb can locate all FDEs.
-  if (OldEHFrameSection) {
-    const uint64_t EHFrameSectionSize = (OldEHFrameSection->getOutputAddress() +
-                                         OldEHFrameSection->getOutputSize() -
-                                         EHFrameSection->getOutputAddress());
-    EHFrameSection =
-      BC->registerOrUpdateSection(".eh_frame",
-                                  EHFrameSection->getELFType(),
-                                  EHFrameSection->getELFFlags(),
-                                  EHFrameSection->getOutputData(),
-                                  EHFrameSectionSize,
-                                  EHFrameSection->getAlignment());
-    BC->deregisterSection(*OldEHFrameSection);
+  // Merge new .eh_frame with the relocated original so that gdb can locate all
+  // FDEs.
+  if (RelocatedEHFrameSection) {
+    const uint64_t NewEHFrameSectionSize =
+        RelocatedEHFrameSection->getOutputAddress() +
+        RelocatedEHFrameSection->getOutputSize() -
+        NewEHFrameSection->getOutputAddress();
+    NewEHFrameSection->updateContents(NewEHFrameSection->getOutputData(),
+                                      NewEHFrameSectionSize);
+    BC->deregisterSection(*RelocatedEHFrameSection);
   }
 
   LLVM_DEBUG(dbgs() << "BOLT-DEBUG: size of .eh_frame after merge is "
-                    << EHFrameSection->getOutputSize() << '\n');
+                    << NewEHFrameSection->getOutputSize() << '\n');
 }
 
 uint64_t RewriteInstance::getNewValueForSymbol(const StringRef Name) {
   uint64_t Value = RTDyld->getSymbol(Name).getAddress();
   if (Value != 0)
     return Value;
 
   // Return the original value if we haven't emitted the symbol.

bolt/test/X86/dynrelocs.s

 
 # In this test, we create a reference to a dynamic object that will
 # imply in R_X86_64_64 being used for .rodata. Now BOLT, when creating
 # a new .rodata to hold jump table entries, needs to remember to emit
 # these dynamic relocs against the original .rodata, and not the new
 # one it just created.
 
 # REQUIRES: system-linux
-# Currently XFAIL as we do not support it.
-# XFAIL: *
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux \
 # RUN:   %s -o %t.o
 # RUN: link_fdata %s %t.o %t.fdata
 # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux \
 # RUN:   %p/Inputs/define_bar.s -o %t.2.o
 # RUN: llvm-strip --strip-unneeded %t.o
 # RUN: ld.lld %t.2.o -o %t.so -shared