lib/DebugInfo/DWARF/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 "llvm/DebugInfo/DWARF/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 namespace {
 183 /// \brief DWARF Common Information Entry (CIE)
 184 class CIE : public FrameEntry {
 185 public:
 186   // CIEs (and FDEs) are simply container classes, so the only sensible way to
 187   // create them is by providing the full parsed contents in the constructor.
 188   CIE(uint64_t Offset, uint64_t Length, uint8_t Version,
 189       SmallString<8> Augmentation, uint64_t CodeAlignmentFactor,
 190       int64_t DataAlignmentFactor, uint64_t ReturnAddressRegister)
 191       : FrameEntry(FK_CIE, Offset, Length), Version(Version),
 192         Augmentation(std::move(Augmentation)),
 193         CodeAlignmentFactor(CodeAlignmentFactor),
 194         DataAlignmentFactor(DataAlignmentFactor),
 195         ReturnAddressRegister(ReturnAddressRegister) {}
 196
 197   ~CIE() {
 198   }
 199
 200   uint64_t getCodeAlignmentFactor() const { return CodeAlignmentFactor; }
 201   int64_t getDataAlignmentFactor() const { return DataAlignmentFactor; }
 202
 203   void dumpHeader(raw_ostream &OS) const override {
 204     OS << format("%08x %08x %08x CIE",
 205                  (uint32_t)Offset, (uint32_t)Length, DW_CIE_ID)
 206        << "\n";
 207     OS << format("  Version:               %d\n", Version);
 208     OS << "  Augmentation:          \"" << Augmentation << "\"\n";
 209     OS << format("  Code alignment factor: %u\n",
 210                  (uint32_t)CodeAlignmentFactor);
 211     OS << format("  Data alignment factor: %d\n",
 212                  (int32_t)DataAlignmentFactor);
 213     OS << format("  Return address column: %d\n",
 214                  (int32_t)ReturnAddressRegister);
 215     OS << "\n";
 216   }
 217
 218   static bool classof(const FrameEntry *FE) {
 219     return FE->getKind() == FK_CIE;
 220   }
 221
 222 private:
 223   /// The following fields are defined in section 6.4.1 of the DWARF standard v3
 224   uint8_t Version;
 225   SmallString<8> Augmentation;
 226   uint64_t CodeAlignmentFactor;
 227   int64_t DataAlignmentFactor;
 228   uint64_t ReturnAddressRegister;
 229 };
 230
 231
 232 /// \brief DWARF Frame Description Entry (FDE)
 233 class FDE : public FrameEntry {
 234 public:
 235   // Each FDE has a CIE it's "linked to". Our FDE contains is constructed with
 236   // an offset to the CIE (provided by parsing the FDE header). The CIE itself
 237   // is obtained lazily once it's actually required.
 238   FDE(uint64_t Offset, uint64_t Length, int64_t LinkedCIEOffset,
 239       uint64_t InitialLocation, uint64_t AddressRange,
 240       CIE *Cie)
 241       : FrameEntry(FK_FDE, Offset, Length), LinkedCIEOffset(LinkedCIEOffset),
 242         InitialLocation(InitialLocation), AddressRange(AddressRange),
 243         LinkedCIE(Cie) {}
 244
 245   ~FDE() {
 246   }
 247
 248   CIE *getLinkedCIE() const { return LinkedCIE; }
 249
 250   void dumpHeader(raw_ostream &OS) const override {
 251     OS << format("%08x %08x %08x FDE ",
 252                  (uint32_t)Offset, (uint32_t)Length, (int32_t)LinkedCIEOffset);
 253     OS << format("cie=%08x pc=%08x...%08x\n",
 254                  (int32_t)LinkedCIEOffset,
 255                  (uint32_t)InitialLocation,
 256                  (uint32_t)InitialLocation + (uint32_t)AddressRange);
 257     if (LinkedCIE) {
 258       OS << format("%p\n", LinkedCIE);
 259     }
 260   }
 261
 262   static bool classof(const FrameEntry *FE) {
 263     return FE->getKind() == FK_FDE;
 264   }
 265
 266 private:
 267   /// The following fields are defined in section 6.4.1 of the DWARF standard v3
 268   uint64_t LinkedCIEOffset;
 269   uint64_t InitialLocation;
 270   uint64_t AddressRange;
 271   CIE *LinkedCIE;
 272 };
 273 } // end anonymous namespace
 274
 275 void FrameEntry::dumpInstructions(raw_ostream &OS) const {
 276   // TODO: at the moment only instruction names are dumped. Expand this to
 277   // dump operands as well.
 278   for (const auto &Instr : Instructions) {
 279     uint8_t Opcode = Instr.Opcode;
 280     if (Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK)
 281       Opcode &= DWARF_CFI_PRIMARY_OPCODE_MASK;
 282     OS << "  " << CallFrameString(Opcode) << ":\n";
 283   }
 284 }
 285
 286 DWARFDebugFrame::DWARFDebugFrame() {
 287 }
 288
 289 DWARFDebugFrame::~DWARFDebugFrame() {
 290 }
 291
 292 static void LLVM_ATTRIBUTE_UNUSED dumpDataAux(DataExtractor Data,
 293                                               uint32_t Offset, int Length) {
 294   errs() << "DUMP: ";
 295   for (int i = 0; i < Length; ++i) {
 296     uint8_t c = Data.getU8(&Offset);
 297     errs().write_hex(c); errs() << " ";
 298   }
 299   errs() << "\n";
 300 }
 301
 302
 303 void DWARFDebugFrame::parse(DataExtractor Data) {
 304   uint32_t Offset = 0;
 305   DenseMap<uint32_t, CIE *> CIEs;
 306
 307   while (Data.isValidOffset(Offset)) {
 308     uint32_t StartOffset = Offset;
 309
 310     bool IsDWARF64 = false;
 311     uint64_t Length = Data.getU32(&Offset);
 312     uint64_t Id;
 313
 314     if (Length == UINT32_MAX) {
 315       // DWARF-64 is distinguished by the first 32 bits of the initial length
 316       // field being 0xffffffff. Then, the next 64 bits are the actual entry
 317       // length.
 318       IsDWARF64 = true;
 319       Length = Data.getU64(&Offset);
 320     }
 321
 322     // At this point, Offset points to the next field after Length.
 323     // Length is the structure size excluding itself. Compute an offset one
 324     // past the end of the structure (needed to know how many instructions to
 325     // read).
 326     // TODO: For honest DWARF64 support, DataExtractor will have to treat
 327     //       offset_ptr as uint64_t*
 328     uint32_t EndStructureOffset = Offset + static_cast<uint32_t>(Length);
 329
 330     // The Id field's size depends on the DWARF format
 331     Id = Data.getUnsigned(&Offset, IsDWARF64 ? 8 : 4);
 332     bool IsCIE = ((IsDWARF64 && Id == DW64_CIE_ID) || Id == DW_CIE_ID);
 333
 334     if (IsCIE) {
 335       // Note: this is specifically DWARFv3 CIE header structure. It was
 336       // changed in DWARFv4. We currently don't support reading DWARFv4
 337       // here because LLVM itself does not emit it (and LLDB doesn't
 338       // support it either).
 339       uint8_t Version = Data.getU8(&Offset);
 340       const char *Augmentation = Data.getCStr(&Offset);
 341       uint64_t CodeAlignmentFactor = Data.getULEB128(&Offset);
 342       int64_t DataAlignmentFactor = Data.getSLEB128(&Offset);
 343       uint64_t ReturnAddressRegister = Data.getULEB128(&Offset);
 344
 345       auto Cie = make_unique<CIE>(StartOffset, Length, Version,
 346                                   StringRef(Augmentation), CodeAlignmentFactor,
 347                                   DataAlignmentFactor, ReturnAddressRegister);
 348       CIEs[StartOffset] = Cie.get();
 349       Entries.emplace_back(std::move(Cie));
 350     } else {
 351       // FDE
 352       uint64_t CIEPointer = Id;
 353       uint64_t InitialLocation = Data.getAddress(&Offset);
 354       uint64_t AddressRange = Data.getAddress(&Offset);
 355
 356       Entries.emplace_back(new FDE(StartOffset, Length, CIEPointer,
 357                                    InitialLocation, AddressRange,
 358                                    CIEs[CIEPointer]));
 359     }
 360
 361     Entries.back()->parseInstructions(Data, &Offset, EndStructureOffset);
 362
 363     if (Offset != EndStructureOffset) {
 364       std::string Str;
 365       raw_string_ostream OS(Str);
 366       OS << format("Parsing entry instructions at %lx failed", StartOffset);
 367       report_fatal_error(Str);
 368     }
 369   }
 370 }
 371
 372
 373 void DWARFDebugFrame::dump(raw_ostream &OS) const {
 374   OS << "\n";
 375   for (const auto &Entry : Entries) {
 376     Entry->dumpHeader(OS);
 377     Entry->dumpInstructions(OS);
 378     OS << "\n";
 379   }
 380 }
 381