lib/DebugInfo/DWARFDebugFrame.cpp

   1 //===-- DWARFDebugFrame.h - Parsing of .debug_frame -------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "DWARFDebugFrame.h"
  11 #include "llvm/ADT/SmallString.h"
  12 #include "llvm/Support/DataTypes.h"
  13 #include "llvm/Support/Dwarf.h"
  14 #include "llvm/Support/ErrorHandling.h"
  15 #include "llvm/Support/Format.h"
  16 #include "llvm/Support/raw_ostream.h"
  17 #include <string>
  18 #include <vector>
  19
  20 using namespace llvm;
  21 using namespace dwarf;
  22
  23
  24 /// \brief Abstract frame entry defining the common interface concrete
  25 /// entries implement.
  26 class llvm::FrameEntry {
  27 public:
  28   enum FrameKind {FK_CIE, FK_FDE};
  29   FrameEntry(FrameKind K, uint64_t Offset, uint64_t Length)
  30       : Kind(K), Offset(Offset), Length(Length) {}
  31
  32   virtual ~FrameEntry() {
  33   }
  34
  35   FrameKind getKind() const { return Kind; }
  36   virtual uint64_t getOffset() const { return Offset; }
  37
  38   /// \brief Parse and store a sequence of CFI instructions from Data,
  39   /// starting at *Offset and ending at EndOffset. If everything
  40   /// goes well, *Offset should be equal to EndOffset when this method
  41   /// returns. Otherwise, an error occurred.
  42   virtual void parseInstructions(DataExtractor Data, uint32_t *Offset,
  43                                  uint32_t EndOffset);
  44
  45   /// \brief Dump the entry header to the given output stream.
  46   virtual void dumpHeader(raw_ostream &OS) const = 0;
  47
  48   /// \brief Dump the entry's instructions to the given output stream.
  49   virtual void dumpInstructions(raw_ostream &OS) const;
  50
  51 protected:
  52   const FrameKind Kind;
  53
  54   /// \brief Offset of this entry in the section.
  55   uint64_t Offset;
  56
  57   /// \brief Entry length as specified in DWARF.
  58   uint64_t Length;
  59
  60   /// An entry may contain CFI instructions. An instruction consists of an
  61   /// opcode and an optional sequence of operands.
  62   typedef std::vector<uint64_t> Operands;
  63   struct Instruction {
  64     Instruction(uint8_t Opcode)
  65       : Opcode(Opcode)
  66     {}
  67
  68     uint8_t Opcode;
  69     Operands Ops;
  70   };
  71
  72   std::vector<Instruction> Instructions;
  73
  74   /// Convenience methods to add a new instruction with the given opcode and
  75   /// operands to the Instructions vector.
  76   void addInstruction(uint8_t Opcode) {
  77     Instructions.push_back(Instruction(Opcode));
  78   }
  79
  80   void addInstruction(uint8_t Opcode, uint64_t Operand1) {
  81     Instructions.push_back(Instruction(Opcode));
  82     Instructions.back().Ops.push_back(Operand1);
  83   }
  84
  85   void addInstruction(uint8_t Opcode, uint64_t Operand1, uint64_t Operand2) {
  86     Instructions.push_back(Instruction(Opcode));
  87     Instructions.back().Ops.push_back(Operand1);
  88     Instructions.back().Ops.push_back(Operand2);
  89   }
  90 };
  91
  92
  93 // See DWARF standard v3, section 7.23
  94 const uint8_t DWARF_CFI_PRIMARY_OPCODE_MASK = 0xc0;
  95 const uint8_t DWARF_CFI_PRIMARY_OPERAND_MASK = 0x3f;
  96
  97 void FrameEntry::parseInstructions(DataExtractor Data, uint32_t *Offset,
  98                                    uint32_t EndOffset) {
  99   while (*Offset < EndOffset) {
 100     uint8_t Opcode = Data.getU8(Offset);
 101     // Some instructions have a primary opcode encoded in the top bits.
 102     uint8_t Primary = Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK;
 103
 104     if (Primary) {
 105       // If it's a primary opcode, the first operand is encoded in the bottom
 106       // bits of the opcode itself.
 107       uint64_t Op1 = Opcode & DWARF_CFI_PRIMARY_OPERAND_MASK;
 108       switch (Primary) {
 109         default: llvm_unreachable("Impossible primary CFI opcode");
 110         case DW_CFA_advance_loc:
 111         case DW_CFA_restore:
 112           addInstruction(Primary, Op1);
 113           break;
 114         case DW_CFA_offset:
 115           addInstruction(Primary, Op1, Data.getULEB128(Offset));
 116           break;
 117       }
 118     } else {
 119       // Extended opcode - its value is Opcode itself.
 120       switch (Opcode) {
 121         default: llvm_unreachable("Invalid extended CFI opcode");
 122         case DW_CFA_nop:
 123         case DW_CFA_remember_state:
 124         case DW_CFA_restore_state:
 125         case DW_CFA_GNU_window_save:
 126           // No operands
 127           addInstruction(Opcode);
 128           break;
 129         case DW_CFA_set_loc:
 130           // Operands: Address
 131           addInstruction(Opcode, Data.getAddress(Offset));
 132           break;
 133         case DW_CFA_advance_loc1:
 134           // Operands: 1-byte delta
 135           addInstruction(Opcode, Data.getU8(Offset));
 136           break;
 137         case DW_CFA_advance_loc2:
 138           // Operands: 2-byte delta
 139           addInstruction(Opcode, Data.getU16(Offset));
 140           break;
 141         case DW_CFA_advance_loc4:
 142           // Operands: 4-byte delta
 143           addInstruction(Opcode, Data.getU32(Offset));
 144           break;
 145         case DW_CFA_restore_extended:
 146         case DW_CFA_undefined:
 147         case DW_CFA_same_value:
 148         case DW_CFA_def_cfa_register:
 149         case DW_CFA_def_cfa_offset:
 150           // Operands: ULEB128
 151           addInstruction(Opcode, Data.getULEB128(Offset));
 152           break;
 153         case DW_CFA_def_cfa_offset_sf:
 154           // Operands: SLEB128
 155           addInstruction(Opcode, Data.getSLEB128(Offset));
 156           break;
 157         case DW_CFA_offset_extended:
 158         case DW_CFA_register:
 159         case DW_CFA_def_cfa:
 160         case DW_CFA_val_offset:
 161           // Operands: ULEB128, ULEB128
 162           addInstruction(Opcode, Data.getULEB128(Offset),
 163                                  Data.getULEB128(Offset));
 164           break;
 165         case DW_CFA_offset_extended_sf:
 166         case DW_CFA_def_cfa_sf:
 167         case DW_CFA_val_offset_sf:
 168           // Operands: ULEB128, SLEB128
 169           addInstruction(Opcode, Data.getULEB128(Offset),
 170                                  Data.getSLEB128(Offset));
 171           break;
 172         case DW_CFA_def_cfa_expression:
 173         case DW_CFA_expression:
 174         case DW_CFA_val_expression:
 175           // TODO: implement this
 176           report_fatal_error("Values with expressions not implemented yet!");
 177       }
 178     }
 179   }
 180 }
 181
 182
 183 void FrameEntry::dumpInstructions(raw_ostream &OS) const {
 184   // TODO: at the moment only instruction names are dumped. Expand this to
 185   // dump operands as well.
 186   for (const auto &Instr : Instructions) {
 187     uint8_t Opcode = Instr.Opcode;
 188     if (Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK)
 189       Opcode &= DWARF_CFI_PRIMARY_OPCODE_MASK;
 190     OS << "  " << CallFrameString(Opcode) << ":\n";
 191   }
 192 }
 193
 194
 195 namespace {
 196 /// \brief DWARF Common Information Entry (CIE)
 197 class CIE : public FrameEntry {
 198 public:
 199   // CIEs (and FDEs) are simply container classes, so the only sensible way to
 200   // create them is by providing the full parsed contents in the constructor.
 201   CIE(uint64_t Offset, uint64_t Length, uint8_t Version,
 202       SmallString<8> Augmentation, uint64_t CodeAlignmentFactor,
 203       int64_t DataAlignmentFactor, uint64_t ReturnAddressRegister)
 204       : FrameEntry(FK_CIE, Offset, Length), Version(Version),
 205         Augmentation(Augmentation), CodeAlignmentFactor(CodeAlignmentFactor),
 206         DataAlignmentFactor(DataAlignmentFactor),
 207         ReturnAddressRegister(ReturnAddressRegister) {}
 208
 209   ~CIE() {
 210   }
 211
 212   void dumpHeader(raw_ostream &OS) const override {
 213     OS << format("%08x %08x %08x CIE",
 214                  (uint32_t)Offset, (uint32_t)Length, DW_CIE_ID)
 215        << "\n";
 216     OS << format("  Version:               %d\n", Version);
 217     OS << "  Augmentation:          \"" << Augmentation << "\"\n";
 218     OS << format("  Code alignment factor: %u\n",
 219                  (uint32_t)CodeAlignmentFactor);
 220     OS << format("  Data alignment factor: %d\n",
 221                  (int32_t)DataAlignmentFactor);
 222     OS << format("  Return address column: %d\n",
 223                  (int32_t)ReturnAddressRegister);
 224     OS << "\n";
 225   }
 226
 227   static bool classof(const FrameEntry *FE) {
 228     return FE->getKind() == FK_CIE;
 229   }
 230
 231 private:
 232   /// The following fields are defined in section 6.4.1 of the DWARF standard v3
 233   uint8_t Version;
 234   SmallString<8> Augmentation;
 235   uint64_t CodeAlignmentFactor;
 236   int64_t DataAlignmentFactor;
 237   uint64_t ReturnAddressRegister;
 238 };
 239
 240
 241 /// \brief DWARF Frame Description Entry (FDE)
 242 class FDE : public FrameEntry {
 243 public:
 244   // Each FDE has a CIE it's "linked to". Our FDE contains is constructed with
 245   // an offset to the CIE (provided by parsing the FDE header). The CIE itself
 246   // is obtained lazily once it's actually required.
 247   FDE(uint64_t Offset, uint64_t Length, int64_t LinkedCIEOffset,
 248       uint64_t InitialLocation, uint64_t AddressRange)
 249       : FrameEntry(FK_FDE, Offset, Length), LinkedCIEOffset(LinkedCIEOffset),
 250         InitialLocation(InitialLocation), AddressRange(AddressRange),
 251         LinkedCIE(nullptr) {}
 252
 253   ~FDE() {
 254   }
 255
 256   void dumpHeader(raw_ostream &OS) const override {
 257     OS << format("%08x %08x %08x FDE ",
 258                  (uint32_t)Offset, (uint32_t)Length, (int32_t)LinkedCIEOffset);
 259     OS << format("cie=%08x pc=%08x...%08x\n",
 260                  (int32_t)LinkedCIEOffset,
 261                  (uint32_t)InitialLocation,
 262                  (uint32_t)InitialLocation + (uint32_t)AddressRange);
 263     if (LinkedCIE) {
 264       OS << format("%p\n", LinkedCIE);
 265     }
 266   }
 267
 268   static bool classof(const FrameEntry *FE) {
 269     return FE->getKind() == FK_FDE;
 270   }
 271
 272 private:
 273   /// The following fields are defined in section 6.4.1 of the DWARF standard v3
 274   uint64_t LinkedCIEOffset;
 275   uint64_t InitialLocation;
 276   uint64_t AddressRange;
 277   CIE *LinkedCIE;
 278 };
 279 } // end anonymous namespace
 280
 281
 282 DWARFDebugFrame::DWARFDebugFrame() {
 283 }
 284
 285 DWARFDebugFrame::~DWARFDebugFrame() {
 286 }
 287
 288 static void LLVM_ATTRIBUTE_UNUSED dumpDataAux(DataExtractor Data,
 289                                               uint32_t Offset, int Length) {
 290   errs() << "DUMP: ";
 291   for (int i = 0; i < Length; ++i) {
 292     uint8_t c = Data.getU8(&Offset);
 293     errs().write_hex(c); errs() << " ";
 294   }
 295   errs() << "\n";
 296 }
 297
 298
 299 void DWARFDebugFrame::parse(DataExtractor Data) {
 300   uint32_t Offset = 0;
 301
 302   while (Data.isValidOffset(Offset)) {
 303     uint32_t StartOffset = Offset;
 304
 305     bool IsDWARF64 = false;
 306     uint64_t Length = Data.getU32(&Offset);
 307     uint64_t Id;
 308
 309     if (Length == UINT32_MAX) {
 310       // DWARF-64 is distinguished by the first 32 bits of the initial length
 311       // field being 0xffffffff. Then, the next 64 bits are the actual entry
 312       // length.
 313       IsDWARF64 = true;
 314       Length = Data.getU64(&Offset);
 315     }
 316
 317     // At this point, Offset points to the next field after Length.
 318     // Length is the structure size excluding itself. Compute an offset one
 319     // past the end of the structure (needed to know how many instructions to
 320     // read).
 321     // TODO: For honest DWARF64 support, DataExtractor will have to treat
 322     //       offset_ptr as uint64_t*
 323     uint32_t EndStructureOffset = Offset + static_cast<uint32_t>(Length);
 324
 325     // The Id field's size depends on the DWARF format
 326     Id = Data.getUnsigned(&Offset, IsDWARF64 ? 8 : 4);
 327     bool IsCIE = ((IsDWARF64 && Id == DW64_CIE_ID) || Id == DW_CIE_ID);
 328
 329     if (IsCIE) {
 330       // Note: this is specifically DWARFv3 CIE header structure. It was
 331       // changed in DWARFv4. We currently don't support reading DWARFv4
 332       // here because LLVM itself does not emit it (and LLDB doesn't
 333       // support it either).
 334       uint8_t Version = Data.getU8(&Offset);
 335       const char *Augmentation = Data.getCStr(&Offset);
 336       uint64_t CodeAlignmentFactor = Data.getULEB128(&Offset);
 337       int64_t DataAlignmentFactor = Data.getSLEB128(&Offset);
 338       uint64_t ReturnAddressRegister = Data.getULEB128(&Offset);
 339
 340       Entries.emplace_back(new CIE(StartOffset, Length, Version,
 341                                    StringRef(Augmentation), CodeAlignmentFactor,
 342                                    DataAlignmentFactor, ReturnAddressRegister));
 343     } else {
 344       // FDE
 345       uint64_t CIEPointer = Id;
 346       uint64_t InitialLocation = Data.getAddress(&Offset);
 347       uint64_t AddressRange = Data.getAddress(&Offset);
 348
 349       Entries.emplace_back(new FDE(StartOffset, Length, CIEPointer,
 350                                    InitialLocation, AddressRange));
 351     }
 352
 353     Entries.back()->parseInstructions(Data, &Offset, EndStructureOffset);
 354
 355     if (Offset != EndStructureOffset) {
 356       std::string Str;
 357       raw_string_ostream OS(Str);
 358       OS << format("Parsing entry instructions at %lx failed", StartOffset);
 359       report_fatal_error(Str);
 360     }
 361   }
 362 }
 363
 364
 365 void DWARFDebugFrame::dump(raw_ostream &OS) const {
 366   OS << "\n";
 367   for (const auto &Entry : Entries) {
 368     Entry->dumpHeader(OS);
 369     Entry->dumpInstructions(OS);
 370     OS << "\n";
 371   }
 372 }
 373