tools/llvm-readobj/DwarfCFIEHPrinter.h

   1 //===--- DwarfCFIEHPrinter.h - DWARF-based Unwind Information Printer -----===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef LLVM_TOOLS_LLVM_READOBJ_DWARFCFIEHPRINTER_H
  10 #define LLVM_TOOLS_LLVM_READOBJ_DWARFCFIEHPRINTER_H
  11
  12 #include "Error.h"
  13 #include "llvm-readobj.h"
  14 #include "llvm/ADT/STLExtras.h"
  15 #include "llvm/BinaryFormat/Dwarf.h"
  16 #include "llvm/Object/ELF.h"
  17 #include "llvm/Object/ELFTypes.h"
  18 #include "llvm/Object/ELFObjectFile.h"
  19 #include "llvm/Support/Casting.h"
  20 #include "llvm/Support/ScopedPrinter.h"
  21 #include "llvm/Support/Debug.h"
  22 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
  23 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
  24 #include "llvm/Support/Endian.h"
  25 #include "llvm/Support/Format.h"
  26 #include "llvm/Support/type_traits.h"
  27
  28 namespace llvm {
  29 namespace DwarfCFIEH {
  30
  31 template <typename ELFT>
  32 class PrinterContext {
  33   ScopedPrinter &W;
  34   const object::ELFObjectFile<ELFT> *ObjF;
  35
  36   void printEHFrameHdr(uint64_t Offset, uint64_t Address, uint64_t Size) const;
  37
  38   void printEHFrame(const typename ELFT::Shdr *EHFrameShdr) const;
  39
  40 public:
  41   PrinterContext(ScopedPrinter &W, const object::ELFObjectFile<ELFT> *ObjF)
  42       : W(W), ObjF(ObjF) {}
  43
  44   void printUnwindInformation() const;
  45 };
  46
  47 template <class ELFO>
  48 static const typename ELFO::Elf_Shdr *findSectionByAddress(const ELFO *Obj,
  49                                                            uint64_t Addr) {
  50   auto Sections = Obj->sections();
  51   if (Error E = Sections.takeError())
  52     reportError(toString(std::move(E)));
  53
  54   for (const auto &Shdr : *Sections)
  55     if (Shdr.sh_addr == Addr)
  56       return &Shdr;
  57   return nullptr;
  58 }
  59
  60 template <typename ELFT>
  61 void PrinterContext<ELFT>::printUnwindInformation() const {
  62   const object::ELFFile<ELFT> *Obj = ObjF->getELFFile();
  63   const typename ELFT::Phdr *EHFramePhdr = nullptr;
  64
  65   auto PHs = Obj->program_headers();
  66   if (Error E = PHs.takeError())
  67     reportError(toString(std::move(E)));
  68
  69   for (const auto &Phdr : *PHs) {
  70     if (Phdr.p_type == ELF::PT_GNU_EH_FRAME) {
  71       EHFramePhdr = &Phdr;
  72       if (Phdr.p_memsz != Phdr.p_filesz)
  73         reportError("p_memsz does not match p_filesz for GNU_EH_FRAME");
  74       break;
  75     }
  76   }
  77
  78   if (EHFramePhdr)
  79     printEHFrameHdr(EHFramePhdr->p_offset, EHFramePhdr->p_vaddr,
  80                     EHFramePhdr->p_memsz);
  81
  82   auto Sections = Obj->sections();
  83   if (Error E = Sections.takeError())
  84     reportError(toString(std::move(E)));
  85
  86   for (const auto &Shdr : *Sections) {
  87     auto SectionName = Obj->getSectionName(&Shdr);
  88     if (Error E = SectionName.takeError())
  89       reportError(toString(std::move(E)));
  90
  91     if (*SectionName == ".eh_frame")
  92       printEHFrame(&Shdr);
  93   }
  94 }
  95
  96 template <typename ELFT>
  97 void PrinterContext<ELFT>::printEHFrameHdr(uint64_t EHFrameHdrOffset,
  98                                            uint64_t EHFrameHdrAddress,
  99                                            uint64_t EHFrameHdrSize) const {
 100   ListScope L(W, "EH_FRAME Header");
 101   W.startLine() << format("Address: 0x%" PRIx64 "\n", EHFrameHdrAddress);
 102   W.startLine() << format("Offset: 0x%" PRIx64 "\n", EHFrameHdrOffset);
 103   W.startLine() << format("Size: 0x%" PRIx64 "\n", EHFrameHdrSize);
 104
 105   const object::ELFFile<ELFT> *Obj = ObjF->getELFFile();
 106   const auto *EHFrameHdrShdr = findSectionByAddress(Obj, EHFrameHdrAddress);
 107   if (EHFrameHdrShdr) {
 108     auto SectionName = Obj->getSectionName(EHFrameHdrShdr);
 109     if (Error E = SectionName.takeError())
 110       reportError(toString(std::move(E)));
 111
 112     W.printString("Corresponding Section", *SectionName);
 113   }
 114
 115   DataExtractor DE(
 116       StringRef(reinterpret_cast<const char *>(Obj->base()) + EHFrameHdrOffset,
 117                 EHFrameHdrSize),
 118       ELFT::TargetEndianness == support::endianness::little,
 119       ELFT::Is64Bits ? 8 : 4);
 120
 121   DictScope D(W, "Header");
 122   uint64_t Offset = 0;
 123
 124   auto Version = DE.getU8(&Offset);
 125   W.printNumber("version", Version);
 126   if (Version != 1)
 127     reportError("only version 1 of .eh_frame_hdr is supported");
 128
 129   uint64_t EHFramePtrEnc = DE.getU8(&Offset);
 130   W.startLine() << format("eh_frame_ptr_enc: 0x%" PRIx64 "\n", EHFramePtrEnc);
 131   if (EHFramePtrEnc != (dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4))
 132     reportError("unexpected encoding eh_frame_ptr_enc");
 133
 134   uint64_t FDECountEnc = DE.getU8(&Offset);
 135   W.startLine() << format("fde_count_enc: 0x%" PRIx64 "\n", FDECountEnc);
 136   if (FDECountEnc != dwarf::DW_EH_PE_udata4)
 137     reportError("unexpected encoding fde_count_enc");
 138
 139   uint64_t TableEnc = DE.getU8(&Offset);
 140   W.startLine() << format("table_enc: 0x%" PRIx64 "\n", TableEnc);
 141   if (TableEnc != (dwarf::DW_EH_PE_datarel | dwarf::DW_EH_PE_sdata4))
 142     reportError("unexpected encoding table_enc");
 143
 144   auto EHFramePtr = DE.getSigned(&Offset, 4) + EHFrameHdrAddress + 4;
 145   W.startLine() << format("eh_frame_ptr: 0x%" PRIx64 "\n", EHFramePtr);
 146
 147   auto FDECount = DE.getUnsigned(&Offset, 4);
 148   W.printNumber("fde_count", FDECount);
 149
 150   unsigned NumEntries = 0;
 151   uint64_t PrevPC = 0;
 152   while (Offset + 8 <= EHFrameHdrSize && NumEntries < FDECount) {
 153     DictScope D(W, std::string("entry ")  + std::to_string(NumEntries));
 154
 155     auto InitialPC = DE.getSigned(&Offset, 4) + EHFrameHdrAddress;
 156     W.startLine() << format("initial_location: 0x%" PRIx64 "\n", InitialPC);
 157     auto Address = DE.getSigned(&Offset, 4) + EHFrameHdrAddress;
 158     W.startLine() << format("address: 0x%" PRIx64 "\n", Address);
 159
 160     if (InitialPC < PrevPC)
 161       reportError("initial_location is out of order");
 162
 163     PrevPC = InitialPC;
 164     ++NumEntries;
 165   }
 166 }
 167
 168 template <typename ELFT>
 169 void PrinterContext<ELFT>::printEHFrame(
 170     const typename ELFT::Shdr *EHFrameShdr) const {
 171   uint64_t Address = EHFrameShdr->sh_addr;
 172   uint64_t ShOffset = EHFrameShdr->sh_offset;
 173   W.startLine() << format(".eh_frame section at offset 0x%" PRIx64
 174                           " address 0x%" PRIx64 ":\n",
 175                           ShOffset, Address);
 176   W.indent();
 177
 178   const object::ELFFile<ELFT> *Obj = ObjF->getELFFile();
 179   auto Result = Obj->getSectionContents(EHFrameShdr);
 180   if (Error E = Result.takeError())
 181     reportError(toString(std::move(E)));
 182
 183   auto Contents = Result.get();
 184   DWARFDataExtractor DE(
 185       StringRef(reinterpret_cast<const char *>(Contents.data()),
 186                 Contents.size()),
 187       ELFT::TargetEndianness == support::endianness::little,
 188       ELFT::Is64Bits ? 8 : 4);
 189   DWARFDebugFrame EHFrame(Triple::ArchType(ObjF->getArch()), /*IsEH=*/true,
 190                           /*EHFrameAddress=*/Address);
 191   EHFrame.parse(DE);
 192
 193   for (const auto &Entry : EHFrame) {
 194     if (const auto *CIE = dyn_cast<dwarf::CIE>(&Entry)) {
 195       W.startLine() << format("[0x%" PRIx64 "] CIE length=%" PRIu64 "\n",
 196                               Address + CIE->getOffset(),
 197                               CIE->getLength());
 198       W.indent();
 199
 200       W.printNumber("version", CIE->getVersion());
 201       W.printString("augmentation", CIE->getAugmentationString());
 202       W.printNumber("code_alignment_factor", CIE->getCodeAlignmentFactor());
 203       W.printNumber("data_alignment_factor", CIE->getDataAlignmentFactor());
 204       W.printNumber("return_address_register", CIE->getReturnAddressRegister());
 205
 206       W.getOStream() << "\n";
 207       W.startLine() << "Program:\n";
 208       W.indent();
 209       CIE->cfis().dump(W.getOStream(), nullptr, W.getIndentLevel());
 210       W.unindent();
 211
 212       W.unindent();
 213       W.getOStream() << "\n";
 214
 215     } else if (const auto *FDE = dyn_cast<dwarf::FDE>(&Entry)) {
 216       W.startLine() << format("[0x%" PRIx64 "] FDE length=%" PRIu64
 217                               " cie=[0x%" PRIx64 "]\n",
 218                               Address + FDE->getOffset(),
 219                               FDE->getLength(),
 220                               Address + FDE->getLinkedCIE()->getOffset());
 221       W.indent();
 222
 223       W.startLine() << format("initial_location: 0x%" PRIx64 "\n",
 224                               FDE->getInitialLocation());
 225       W.startLine()
 226         << format("address_range: 0x%" PRIx64 " (end : 0x%" PRIx64 ")\n",
 227                   FDE->getAddressRange(),
 228                   FDE->getInitialLocation() + FDE->getAddressRange());
 229
 230       W.getOStream() << "\n";
 231       W.startLine() << "Program:\n";
 232       W.indent();
 233       FDE->cfis().dump(W.getOStream(), nullptr, W.getIndentLevel());
 234       W.unindent();
 235
 236       W.unindent();
 237       W.getOStream() << "\n";
 238     } else {
 239       llvm_unreachable("unexpected DWARF frame kind");
 240     }
 241   }
 242
 243   W.unindent();
 244 }
 245
 246 }
 247 }
 248
 249 #endif