[DEMO]

[grimar]

Summary

For demonstration purposes only.

include/llvm/MC/MCObjectFileInfo.h

 //===-- llvm/MC/MCObjectFileInfo.h - Object File Info -----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file describes common object file formats.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCOBJECTFILEINFO_H
 #define LLVM_MC_MCOBJECTFILEINFO_H
 
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/CodeGen.h"
 
 namespace llvm {
 class MCContext;
 class MCSection;
 
 class MCObjectFileInfo {
protected:
 
   /// FaultMap section.
   MCSection *FaultMapSection;
 
   /// EH frame section.
   ///
   /// It is initialized on demand so it can be overwritten (with uniquing).
   MCSection *EHFrameSection;
+  llvm::DenseMap<const MCSection*, unsigned> EHFrameUniquing;
 
   // ELF specific sections.
   MCSection *DataRelROSection;
   MCSection *MergeableConst4Section;
   MCSection *MergeableConst8Section;
   MCSection *MergeableConst16Section;
   MCSection *MergeableConst32Section;
 
public:
   }
 
   // COFF specific sections.
   MCSection *getDrectveSection() const { return DrectveSection; }
   MCSection *getPDataSection() const { return PDataSection; }
   MCSection *getXDataSection() const { return XDataSection; }
   MCSection *getSXDataSection() const { return SXDataSection; }
 
-  MCSection *getEHFrameSection() {
-    return EHFrameSection;
-  }
+  MCSection *getEHFrameSection(const MCSection &TextSec);
 
   enum Environment { IsMachO, IsELF, IsCOFF, IsWasm };
   Environment getObjectFileType() const { return Env; }
 
   bool isPositionIndependent() const { return PositionIndependent; }
 
 private:
   Environment Env;

lib/MC/ELFObjectWriter.cpp

void ELFObjectWriter::writeSection(const SectionIndexMapTy &SectionIndexMap,
   case ELF::SHT_SYMTAB_SHNDX:
     sh_link = SymbolTableIndex;
     break;
 
   case ELF::SHT_GROUP:
     sh_link = SymbolTableIndex;
     sh_info = GroupSymbolIndex;
     break;
+
+  case ELF::SHT_X86_64_UNWIND:
+    if (const MCSymbol *Sym = Section.getAssociatedSymbol()) {
+      const MCSectionELF *Sec = cast<MCSectionELF>(&Sym->getSection());
+      sh_link = SectionIndexMap.lookup(Sec);
+    }
+    break;
   }
 
   if (Section.getFlags() & ELF::SHF_LINK_ORDER) {
     const MCSymbol *Sym = Section.getAssociatedSymbol();
     const MCSectionELF *Sec = cast<MCSectionELF>(&Sym->getSection());
     sh_link = SectionIndexMap.lookup(Sec);
   }
 

lib/MC/MCDwarf.cpp

void FrameEmitterImpl::EmitFDE(const MCSymbol &cieStart,
 
   Streamer.EmitLabel(fdeEnd);
 }
 
 namespace {
 
 struct CIEKey {
   static const CIEKey getEmptyKey() {
-    return CIEKey(nullptr, 0, -1, false, false, static_cast<unsigned>(INT_MAX));
+    return CIEKey(nullptr, nullptr, 0, -1, false, false,
+                  static_cast<unsigned>(INT_MAX));
   }
 
   static const CIEKey getTombstoneKey() {
-    return CIEKey(nullptr, -1, 0, false, false, static_cast<unsigned>(INT_MAX));
+    return CIEKey(nullptr, nullptr, -1, 0, false, false,
+                  static_cast<unsigned>(INT_MAX));
   }
 
-  CIEKey(const MCSymbol *Personality, unsigned PersonalityEncoding,
-         unsigned LSDAEncoding, bool IsSignalFrame, bool IsSimple,
-         unsigned RAReg)
-      : Personality(Personality), PersonalityEncoding(PersonalityEncoding),
-        LsdaEncoding(LSDAEncoding), IsSignalFrame(IsSignalFrame),
-        IsSimple(IsSimple), RAReg(RAReg) {}
+  CIEKey(const MCSection *TextSec, const MCSymbol *Personality,
+         unsigned PersonalityEncoding, unsigned LSDAEncoding,
+         bool IsSignalFrame, bool IsSimple, unsigned RAReg)
+      : TextSec(TextSec), Personality(Personality),
+        PersonalityEncoding(PersonalityEncoding), LsdaEncoding(LSDAEncoding),
+        IsSignalFrame(IsSignalFrame), IsSimple(IsSimple), RAReg(RAReg) {}
 
   explicit CIEKey(const MCDwarfFrameInfo &Frame)
-      : Personality(Frame.Personality),
+      : TextSec(&Frame.Begin->getSection()), Personality(Frame.Personality),
         PersonalityEncoding(Frame.PersonalityEncoding),
         LsdaEncoding(Frame.LsdaEncoding), IsSignalFrame(Frame.IsSignalFrame),
         IsSimple(Frame.IsSimple), RAReg(Frame.RAReg) {}
 
+  const MCSection *TextSec;
   const MCSymbol *Personality;
   unsigned PersonalityEncoding;
   unsigned LsdaEncoding;
   bool IsSignalFrame;
   bool IsSimple;
   unsigned RAReg;
 };
 
 } // end anonymous namespace
 
 namespace llvm {
 
 template <> struct DenseMapInfo<CIEKey> {
   static CIEKey getEmptyKey() { return CIEKey::getEmptyKey(); }
   static CIEKey getTombstoneKey() { return CIEKey::getTombstoneKey(); }
 
   static unsigned getHashValue(const CIEKey &Key) {
-    return static_cast<unsigned>(
-        hash_combine(Key.Personality, Key.PersonalityEncoding, Key.LsdaEncoding,
-                     Key.IsSignalFrame, Key.IsSimple, Key.RAReg));
+    return static_cast<unsigned>(hash_combine(
+        Key.TextSec, Key.Personality, Key.PersonalityEncoding, Key.LsdaEncoding,
   }
 
   static bool isEqual(const CIEKey &LHS, const CIEKey &RHS) {
-    return LHS.Personality == RHS.Personality &&
+    return LHS.TextSec == RHS.TextSec && LHS.Personality == RHS.Personality &&
            LHS.PersonalityEncoding == RHS.PersonalityEncoding &&
            LHS.LsdaEncoding == RHS.LsdaEncoding &&
            LHS.IsSignalFrame == RHS.IsSignalFrame &&
-           LHS.IsSimple == RHS.IsSimple &&
-           LHS.RAReg == RHS.RAReg;
+           LHS.IsSimple == RHS.IsSimple && LHS.RAReg == RHS.RAReg;
   }
 };
 
 } // end namespace llvm
 
 void MCDwarfFrameEmitter::Emit(MCObjectStreamer &Streamer, MCAsmBackend *MAB,
                                bool IsEH) {
   Streamer.generateCompactUnwindEncodings(MAB);
for (const MCDwarfFrameInfo &Frame : FrameArray) {
       }
       NeedsEHFrameSection |=
         Frame.CompactUnwindEncoding ==
           MOFI->getCompactUnwindDwarfEHFrameOnly();
       Emitter.EmitCompactUnwind(Frame);
     }
   }
 
-  if (!NeedsEHFrameSection) return;
+  if (!NeedsEHFrameSection)
+    return;
 
-  MCSection &Section =
-      IsEH ? *const_cast<MCObjectFileInfo *>(MOFI)->getEHFrameSection()
-           : *MOFI->getDwarfFrameSection();
+  MapVector<MCSection *, std::vector<const MCDwarfFrameInfo *>> EHSections;
+  for (const MCDwarfFrameInfo& FI : FrameArray) {
+    // Don't generate an EH frame if we don't need one. I.e.,
+    // it's taken care of by the compact unwind encoding.
+    if (MOFI->getOmitDwarfIfHaveCompactUnwind() &&
+        FI.CompactUnwindEncoding != MOFI->getCompactUnwindDwarfEHFrameOnly())
+      continue;
 
-  Streamer.SwitchSection(&Section);
-  MCSymbol *SectionStart = Context.createTempSymbol();
-  Streamer.EmitLabel(SectionStart);
+    const MCSection &FrameSec = FI.Begin->getSection();
+    MCSection *Section =
+        IsEH ? const_cast<MCObjectFileInfo *>(MOFI)->getEHFrameSection(FrameSec)
+             : MOFI->getDwarfFrameSection();
+    EHSections[Section].push_back(&FI);
+  }
 
   DenseMap<CIEKey, const MCSymbol *> CIEStarts;
-
   const MCSymbol *DummyDebugKey = nullptr;
-  bool CanOmitDwarf = MOFI->getOmitDwarfIfHaveCompactUnwind();
-  for (auto I = FrameArray.begin(), E = FrameArray.end(); I != E;) {
-    const MCDwarfFrameInfo &Frame = *I;
-    ++I;
-    if (CanOmitDwarf && Frame.CompactUnwindEncoding !=
-          MOFI->getCompactUnwindDwarfEHFrameOnly())
-      // Don't generate an EH frame if we don't need one. I.e., it's taken care
-      // of by the compact unwind encoding.
-      continue;
+  for (auto &P : EHSections) {
+    Streamer.SwitchSection(P.first);
+    MCSymbol *SectionStart = Context.createTempSymbol();
+    Streamer.EmitLabel(SectionStart);
 
-    CIEKey Key(Frame);
+    std::vector<const MCDwarfFrameInfo *> &Frames = P.second;
+    size_t I = 0;
+    for (const MCDwarfFrameInfo *Frame : Frames) {
+      CIEKey Key(*Frame);
       const MCSymbol *&CIEStart = IsEH ? CIEStarts[Key] : DummyDebugKey;
       if (!CIEStart)
-      CIEStart = &Emitter.EmitCIE(Frame);
+        CIEStart = &Emitter.EmitCIE(*Frame);
 
-    Emitter.EmitFDE(*CIEStart, Frame, I == E, *SectionStart);
+      bool LastFrame = I == Frames.size() - 1;
+      Emitter.EmitFDE(*CIEStart, *Frame, LastFrame, *SectionStart);
+      ++I;
+    }
   }
 }
 
 void MCDwarfFrameEmitter::EmitAdvanceLoc(MCObjectStreamer &Streamer,
                                          uint64_t AddrDelta) {
   MCContext &Context = Streamer.getContext();
   SmallString<256> Tmp;
   raw_svector_ostream OS(Tmp);

lib/MC/MCObjectFileInfo.cpp

case Triple::UnknownObjectFormat:
     break;
   }
 }
 
 MCSection *MCObjectFileInfo::getDwarfTypesSection(uint64_t Hash) const {
   return Ctx->getELFSection(".debug_types", ELF::SHT_PROGBITS, ELF::SHF_GROUP,
                             0, utostr(Hash));
 }
+
+MCSection *MCObjectFileInfo::getEHFrameSection(const MCSection &TextSec) {
+  if (Env != IsELF)
+    return EHFrameSection;
+
+  unsigned ID =
+      EHFrameUniquing.insert({&TextSec, EHFrameUniquing.size()}).first->second;
+
+  // Set flags and type corresponding to default .eh_frame section attributes
+  // for ELF target. Specify corresponding .text section as a Link so that we
+  // can set sh_link field later.
+  const MCSectionELF &EHSec = cast<MCSectionELF>(*EHFrameSection);
+  const MCSymbolELF *Link = cast<MCSymbolELF>(TextSec.getBeginSymbol());
+  return Ctx->getELFSection(
+      ".eh_frame", EHSec.getType(), EHSec.getFlags() /*| ELF::SHF_LINK_ORDER*/,
+      0 /*EntrySize*/, "" /*Group*/, ID /*UniqueID*/, Link);
+}