Home | History | Annotate | Download | only in DWARF 
      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/ArrayRef.h"
     12 #include "llvm/ADT/DenseMap.h"
     13 #include "llvm/ADT/SmallString.h"
     14 #include "llvm/Support/Casting.h"
     15 #include "llvm/Support/DataTypes.h"
     16 #include "llvm/Support/Dwarf.h"
     17 #include "llvm/Support/ErrorHandling.h"
     18 #include "llvm/Support/Format.h"
     19 #include "llvm/Support/raw_ostream.h"
     20 #include <string>
     21 #include <vector>
     22 
     23 using namespace llvm;
     24 using namespace dwarf;
     25 
     26 
     27 /// \brief Abstract frame entry defining the common interface concrete
     28 /// entries implement.
     29 class llvm::FrameEntry {
     30 public:
     31   enum FrameKind {FK_CIE, FK_FDE};
     32   FrameEntry(FrameKind K, uint64_t Offset, uint64_t Length)
     33       : Kind(K), Offset(Offset), Length(Length) {}
     34 
     35   virtual ~FrameEntry() {
     36   }
     37 
     38   FrameKind getKind() const { return Kind; }
     39   virtual uint64_t getOffset() const { return Offset; }
     40 
     41   /// \brief Parse and store a sequence of CFI instructions from Data,
     42   /// starting at *Offset and ending at EndOffset. If everything
     43   /// goes well, *Offset should be equal to EndOffset when this method
     44   /// returns. Otherwise, an error occurred.
     45   virtual void parseInstructions(DataExtractor Data, uint32_t *Offset,
     46                                  uint32_t EndOffset);
     47 
     48   /// \brief Dump the entry header to the given output stream.
     49   virtual void dumpHeader(raw_ostream &OS) const = 0;
     50 
     51   /// \brief Dump the entry's instructions to the given output stream.
     52   virtual void dumpInstructions(raw_ostream &OS) const;
     53 
     54 protected:
     55   const FrameKind Kind;
     56 
     57   /// \brief Offset of this entry in the section.
     58   uint64_t Offset;
     59 
     60   /// \brief Entry length as specified in DWARF.
     61   uint64_t Length;
     62 
     63   /// An entry may contain CFI instructions. An instruction consists of an
     64   /// opcode and an optional sequence of operands.
     65   typedef std::vector<uint64_t> Operands;
     66   struct Instruction {
     67     Instruction(uint8_t Opcode)
     68       : Opcode(Opcode)
     69     {}
     70 
     71     uint8_t Opcode;
     72     Operands Ops;
     73   };
     74 
     75   std::vector<Instruction> Instructions;
     76 
     77   /// Convenience methods to add a new instruction with the given opcode and
     78   /// operands to the Instructions vector.
     79   void addInstruction(uint8_t Opcode) {
     80     Instructions.push_back(Instruction(Opcode));
     81   }
     82 
     83   void addInstruction(uint8_t Opcode, uint64_t Operand1) {
     84     Instructions.push_back(Instruction(Opcode));
     85     Instructions.back().Ops.push_back(Operand1);
     86   }
     87 
     88   void addInstruction(uint8_t Opcode, uint64_t Operand1, uint64_t Operand2) {
     89     Instructions.push_back(Instruction(Opcode));
     90     Instructions.back().Ops.push_back(Operand1);
     91     Instructions.back().Ops.push_back(Operand2);
     92   }
     93 };
     94 
     95 
     96 // See DWARF standard v3, section 7.23
     97 const uint8_t DWARF_CFI_PRIMARY_OPCODE_MASK = 0xc0;
     98 const uint8_t DWARF_CFI_PRIMARY_OPERAND_MASK = 0x3f;
     99 
    100 void FrameEntry::parseInstructions(DataExtractor Data, uint32_t *Offset,
    101                                    uint32_t EndOffset) {
    102   while (*Offset < EndOffset) {
    103     uint8_t Opcode = Data.getU8(Offset);
    104     // Some instructions have a primary opcode encoded in the top bits.
    105     uint8_t Primary = Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK;
    106 
    107     if (Primary) {
    108       // If it's a primary opcode, the first operand is encoded in the bottom
    109       // bits of the opcode itself.
    110       uint64_t Op1 = Opcode & DWARF_CFI_PRIMARY_OPERAND_MASK;
    111       switch (Primary) {
    112         default: llvm_unreachable("Impossible primary CFI opcode");
    113         case DW_CFA_advance_loc:
    114         case DW_CFA_restore:
    115           addInstruction(Primary, Op1);
    116           break;
    117         case DW_CFA_offset:
    118           addInstruction(Primary, Op1, Data.getULEB128(Offset));
    119           break;
    120       }
    121     } else {
    122       // Extended opcode - its value is Opcode itself.
    123       switch (Opcode) {
    124         default: llvm_unreachable("Invalid extended CFI opcode");
    125         case DW_CFA_nop:
    126         case DW_CFA_remember_state:
    127         case DW_CFA_restore_state:
    128         case DW_CFA_GNU_window_save:
    129           // No operands
    130           addInstruction(Opcode);
    131           break;
    132         case DW_CFA_set_loc:
    133           // Operands: Address
    134           addInstruction(Opcode, Data.getAddress(Offset));
    135           break;
    136         case DW_CFA_advance_loc1:
    137           // Operands: 1-byte delta
    138           addInstruction(Opcode, Data.getU8(Offset));
    139           break;
    140         case DW_CFA_advance_loc2:
    141           // Operands: 2-byte delta
    142           addInstruction(Opcode, Data.getU16(Offset));
    143           break;
    144         case DW_CFA_advance_loc4:
    145           // Operands: 4-byte delta
    146           addInstruction(Opcode, Data.getU32(Offset));
    147           break;
    148         case DW_CFA_restore_extended:
    149         case DW_CFA_undefined:
    150         case DW_CFA_same_value:
    151         case DW_CFA_def_cfa_register:
    152         case DW_CFA_def_cfa_offset:
    153           // Operands: ULEB128
    154           addInstruction(Opcode, Data.getULEB128(Offset));
    155           break;
    156         case DW_CFA_def_cfa_offset_sf:
    157           // Operands: SLEB128
    158           addInstruction(Opcode, Data.getSLEB128(Offset));
    159           break;
    160         case DW_CFA_offset_extended:
    161         case DW_CFA_register:
    162         case DW_CFA_def_cfa:
    163         case DW_CFA_val_offset:
    164           // Operands: ULEB128, ULEB128
    165           addInstruction(Opcode, Data.getULEB128(Offset),
    166                                  Data.getULEB128(Offset));
    167           break;
    168         case DW_CFA_offset_extended_sf:
    169         case DW_CFA_def_cfa_sf:
    170         case DW_CFA_val_offset_sf:
    171           // Operands: ULEB128, SLEB128
    172           addInstruction(Opcode, Data.getULEB128(Offset),
    173                                  Data.getSLEB128(Offset));
    174           break;
    175         case DW_CFA_def_cfa_expression:
    176         case DW_CFA_expression:
    177         case DW_CFA_val_expression:
    178           // TODO: implement this
    179           report_fatal_error("Values with expressions not implemented yet!");
    180       }
    181     }
    182   }
    183 }
    184 
    185 namespace {
    186 /// \brief DWARF Common Information Entry (CIE)
    187 class CIE : public FrameEntry {
    188 public:
    189   // CIEs (and FDEs) are simply container classes, so the only sensible way to
    190   // create them is by providing the full parsed contents in the constructor.
    191   CIE(uint64_t Offset, uint64_t Length, uint8_t Version,
    192       SmallString<8> Augmentation, uint8_t AddressSize,
    193       uint8_t SegmentDescriptorSize, uint64_t CodeAlignmentFactor,
    194       int64_t DataAlignmentFactor, uint64_t ReturnAddressRegister)
    195       : FrameEntry(FK_CIE, Offset, Length), Version(Version),
    196         Augmentation(std::move(Augmentation)),
    197         AddressSize(AddressSize),
    198         SegmentDescriptorSize(SegmentDescriptorSize),
    199         CodeAlignmentFactor(CodeAlignmentFactor),
    200         DataAlignmentFactor(DataAlignmentFactor),
    201         ReturnAddressRegister(ReturnAddressRegister) {}
    202 
    203   ~CIE() override {}
    204 
    205   uint64_t getCodeAlignmentFactor() const { return CodeAlignmentFactor; }
    206   int64_t getDataAlignmentFactor() const { return DataAlignmentFactor; }
    207 
    208   void dumpHeader(raw_ostream &OS) const override {
    209     OS << format("%08x %08x %08x CIE",
    210                  (uint32_t)Offset, (uint32_t)Length, DW_CIE_ID)
    211        << "\n";
    212     OS << format("  Version:               %d\n", Version);
    213     OS << "  Augmentation:          \"" << Augmentation << "\"\n";
    214     if (Version >= 4) {
    215       OS << format("  Address size:          %u\n",
    216                    (uint32_t)AddressSize);
    217       OS << format("  Segment desc size:     %u\n",
    218                    (uint32_t)SegmentDescriptorSize);
    219     }
    220     OS << format("  Code alignment factor: %u\n",
    221                  (uint32_t)CodeAlignmentFactor);
    222     OS << format("  Data alignment factor: %d\n",
    223                  (int32_t)DataAlignmentFactor);
    224     OS << format("  Return address column: %d\n",
    225                  (int32_t)ReturnAddressRegister);
    226     OS << "\n";
    227   }
    228 
    229   static bool classof(const FrameEntry *FE) {
    230     return FE->getKind() == FK_CIE;
    231   }
    232 
    233 private:
    234   /// The following fields are defined in section 6.4.1 of the DWARF standard v4
    235   uint8_t Version;
    236   SmallString<8> Augmentation;
    237   uint8_t AddressSize;
    238   uint8_t SegmentDescriptorSize;
    239   uint64_t CodeAlignmentFactor;
    240   int64_t DataAlignmentFactor;
    241   uint64_t ReturnAddressRegister;
    242 };
    243 
    244 
    245 /// \brief DWARF Frame Description Entry (FDE)
    246 class FDE : public FrameEntry {
    247 public:
    248   // Each FDE has a CIE it's "linked to". Our FDE contains is constructed with
    249   // an offset to the CIE (provided by parsing the FDE header). The CIE itself
    250   // is obtained lazily once it's actually required.
    251   FDE(uint64_t Offset, uint64_t Length, int64_t LinkedCIEOffset,
    252       uint64_t InitialLocation, uint64_t AddressRange,
    253       CIE *Cie)
    254       : FrameEntry(FK_FDE, Offset, Length), LinkedCIEOffset(LinkedCIEOffset),
    255         InitialLocation(InitialLocation), AddressRange(AddressRange),
    256         LinkedCIE(Cie) {}
    257 
    258   ~FDE() override {}
    259 
    260   CIE *getLinkedCIE() const { return LinkedCIE; }
    261 
    262   void dumpHeader(raw_ostream &OS) const override {
    263     OS << format("%08x %08x %08x FDE ",
    264                  (uint32_t)Offset, (uint32_t)Length, (int32_t)LinkedCIEOffset);
    265     OS << format("cie=%08x pc=%08x...%08x\n",
    266                  (int32_t)LinkedCIEOffset,
    267                  (uint32_t)InitialLocation,
    268                  (uint32_t)InitialLocation + (uint32_t)AddressRange);
    269   }
    270 
    271   static bool classof(const FrameEntry *FE) {
    272     return FE->getKind() == FK_FDE;
    273   }
    274 
    275 private:
    276   /// The following fields are defined in section 6.4.1 of the DWARF standard v3
    277   uint64_t LinkedCIEOffset;
    278   uint64_t InitialLocation;
    279   uint64_t AddressRange;
    280   CIE *LinkedCIE;
    281 };
    282 
    283 /// \brief Types of operands to CF instructions.
    284 enum OperandType {
    285   OT_Unset,
    286   OT_None,
    287   OT_Address,
    288   OT_Offset,
    289   OT_FactoredCodeOffset,
    290   OT_SignedFactDataOffset,
    291   OT_UnsignedFactDataOffset,
    292   OT_Register,
    293   OT_Expression
    294 };
    295 
    296 } // end anonymous namespace
    297 
    298 /// \brief Initialize the array describing the types of operands.
    299 static ArrayRef<OperandType[2]> getOperandTypes() {
    300   static OperandType OpTypes[DW_CFA_restore+1][2];
    301 
    302 #define DECLARE_OP2(OP, OPTYPE0, OPTYPE1)       \
    303   do {                                          \
    304     OpTypes[OP][0] = OPTYPE0;                   \
    305     OpTypes[OP][1] = OPTYPE1;                   \
    306   } while (0)
    307 #define DECLARE_OP1(OP, OPTYPE0) DECLARE_OP2(OP, OPTYPE0, OT_None)
    308 #define DECLARE_OP0(OP) DECLARE_OP1(OP, OT_None)
    309 
    310   DECLARE_OP1(DW_CFA_set_loc, OT_Address);
    311   DECLARE_OP1(DW_CFA_advance_loc, OT_FactoredCodeOffset);
    312   DECLARE_OP1(DW_CFA_advance_loc1, OT_FactoredCodeOffset);
    313   DECLARE_OP1(DW_CFA_advance_loc2, OT_FactoredCodeOffset);
    314   DECLARE_OP1(DW_CFA_advance_loc4, OT_FactoredCodeOffset);
    315   DECLARE_OP1(DW_CFA_MIPS_advance_loc8, OT_FactoredCodeOffset);
    316   DECLARE_OP2(DW_CFA_def_cfa, OT_Register, OT_Offset);
    317   DECLARE_OP2(DW_CFA_def_cfa_sf, OT_Register, OT_SignedFactDataOffset);
    318   DECLARE_OP1(DW_CFA_def_cfa_register, OT_Register);
    319   DECLARE_OP1(DW_CFA_def_cfa_offset, OT_Offset);
    320   DECLARE_OP1(DW_CFA_def_cfa_offset_sf, OT_SignedFactDataOffset);
    321   DECLARE_OP1(DW_CFA_def_cfa_expression, OT_Expression);
    322   DECLARE_OP1(DW_CFA_undefined, OT_Register);
    323   DECLARE_OP1(DW_CFA_same_value, OT_Register);
    324   DECLARE_OP2(DW_CFA_offset, OT_Register, OT_UnsignedFactDataOffset);
    325   DECLARE_OP2(DW_CFA_offset_extended, OT_Register, OT_UnsignedFactDataOffset);
    326   DECLARE_OP2(DW_CFA_offset_extended_sf, OT_Register, OT_SignedFactDataOffset);
    327   DECLARE_OP2(DW_CFA_val_offset, OT_Register, OT_UnsignedFactDataOffset);
    328   DECLARE_OP2(DW_CFA_val_offset_sf, OT_Register, OT_SignedFactDataOffset);
    329   DECLARE_OP2(DW_CFA_register, OT_Register, OT_Register);
    330   DECLARE_OP2(DW_CFA_expression, OT_Register, OT_Expression);
    331   DECLARE_OP2(DW_CFA_val_expression, OT_Register, OT_Expression);
    332   DECLARE_OP1(DW_CFA_restore, OT_Register);
    333   DECLARE_OP1(DW_CFA_restore_extended, OT_Register);
    334   DECLARE_OP0(DW_CFA_remember_state);
    335   DECLARE_OP0(DW_CFA_restore_state);
    336   DECLARE_OP0(DW_CFA_GNU_window_save);
    337   DECLARE_OP1(DW_CFA_GNU_args_size, OT_Offset);
    338   DECLARE_OP0(DW_CFA_nop);
    339 
    340 #undef DECLARE_OP0
    341 #undef DECLARE_OP1
    342 #undef DECLARE_OP2
    343   return ArrayRef<OperandType[2]>(&OpTypes[0], DW_CFA_restore+1);
    344 }
    345 
    346 static ArrayRef<OperandType[2]> OpTypes = getOperandTypes();
    347 
    348 /// \brief Print \p Opcode's operand number \p OperandIdx which has
    349 /// value \p Operand.
    350 static void printOperand(raw_ostream &OS, uint8_t Opcode, unsigned OperandIdx,
    351                          uint64_t Operand, uint64_t CodeAlignmentFactor,
    352                          int64_t DataAlignmentFactor) {
    353   assert(OperandIdx < 2);
    354   OperandType Type = OpTypes[Opcode][OperandIdx];
    355 
    356   switch (Type) {
    357   case OT_Unset:
    358     OS << " Unsupported " << (OperandIdx ? "second" : "first") << " operand to";
    359     if (const char *OpcodeName = CallFrameString(Opcode))
    360       OS << " " << OpcodeName;
    361     else
    362       OS << format(" Opcode %x",  Opcode);
    363     break;
    364   case OT_None:
    365     break;
    366   case OT_Address:
    367     OS << format(" %" PRIx64, Operand);
    368     break;
    369   case OT_Offset:
    370     // The offsets are all encoded in a unsigned form, but in practice
    371     // consumers use them signed. It's most certainly legacy due to
    372     // the lack of signed variants in the first Dwarf standards.
    373     OS << format(" %+" PRId64, int64_t(Operand));
    374     break;
    375   case OT_FactoredCodeOffset: // Always Unsigned
    376     if (CodeAlignmentFactor)
    377       OS << format(" %" PRId64, Operand * CodeAlignmentFactor);
    378     else
    379       OS << format(" %" PRId64 "*code_alignment_factor" , Operand);
    380     break;
    381   case OT_SignedFactDataOffset:
    382     if (DataAlignmentFactor)
    383       OS << format(" %" PRId64, int64_t(Operand) * DataAlignmentFactor);
    384     else
    385       OS << format(" %" PRId64 "*data_alignment_factor" , int64_t(Operand));
    386     break;
    387   case OT_UnsignedFactDataOffset:
    388     if (DataAlignmentFactor)
    389       OS << format(" %" PRId64, Operand * DataAlignmentFactor);
    390     else
    391       OS << format(" %" PRId64 "*data_alignment_factor" , Operand);
    392     break;
    393   case OT_Register:
    394     OS << format(" reg%" PRId64, Operand);
    395     break;
    396   case OT_Expression:
    397     OS << " expression";
    398     break;
    399   }
    400 }
    401 
    402 void FrameEntry::dumpInstructions(raw_ostream &OS) const {
    403   uint64_t CodeAlignmentFactor = 0;
    404   int64_t DataAlignmentFactor = 0;
    405   const CIE *Cie = dyn_cast<CIE>(this);
    406 
    407   if (!Cie)
    408     Cie = cast<FDE>(this)->getLinkedCIE();
    409   if (Cie) {
    410     CodeAlignmentFactor = Cie->getCodeAlignmentFactor();
    411     DataAlignmentFactor = Cie->getDataAlignmentFactor();
    412   }
    413 
    414   for (const auto &Instr : Instructions) {
    415     uint8_t Opcode = Instr.Opcode;
    416     if (Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK)
    417       Opcode &= DWARF_CFI_PRIMARY_OPCODE_MASK;
    418     OS << "  " << CallFrameString(Opcode) << ":";
    419     for (unsigned i = 0; i < Instr.Ops.size(); ++i)
    420       printOperand(OS, Opcode, i, Instr.Ops[i], CodeAlignmentFactor,
    421                    DataAlignmentFactor);
    422     OS << '\n';
    423   }
    424 }
    425 
    426 DWARFDebugFrame::DWARFDebugFrame() {
    427 }
    428 
    429 DWARFDebugFrame::~DWARFDebugFrame() {
    430 }
    431 
    432 static void LLVM_ATTRIBUTE_UNUSED dumpDataAux(DataExtractor Data,
    433                                               uint32_t Offset, int Length) {
    434   errs() << "DUMP: ";
    435   for (int i = 0; i < Length; ++i) {
    436     uint8_t c = Data.getU8(&Offset);
    437     errs().write_hex(c); errs() << " ";
    438   }
    439   errs() << "\n";
    440 }
    441 
    442 
    443 void DWARFDebugFrame::parse(DataExtractor Data) {
    444   uint32_t Offset = 0;
    445   DenseMap<uint32_t, CIE *> CIEs;
    446 
    447   while (Data.isValidOffset(Offset)) {
    448     uint32_t StartOffset = Offset;
    449 
    450     bool IsDWARF64 = false;
    451     uint64_t Length = Data.getU32(&Offset);
    452     uint64_t Id;
    453 
    454     if (Length == UINT32_MAX) {
    455       // DWARF-64 is distinguished by the first 32 bits of the initial length
    456       // field being 0xffffffff. Then, the next 64 bits are the actual entry
    457       // length.
    458       IsDWARF64 = true;
    459       Length = Data.getU64(&Offset);
    460     }
    461 
    462     // At this point, Offset points to the next field after Length.
    463     // Length is the structure size excluding itself. Compute an offset one
    464     // past the end of the structure (needed to know how many instructions to
    465     // read).
    466     // TODO: For honest DWARF64 support, DataExtractor will have to treat
    467     //       offset_ptr as uint64_t*
    468     uint32_t EndStructureOffset = Offset + static_cast<uint32_t>(Length);
    469 
    470     // The Id field's size depends on the DWARF format
    471     Id = Data.getUnsigned(&Offset, IsDWARF64 ? 8 : 4);
    472     bool IsCIE = ((IsDWARF64 && Id == DW64_CIE_ID) || Id == DW_CIE_ID);
    473 
    474     if (IsCIE) {
    475       uint8_t Version = Data.getU8(&Offset);
    476       const char *Augmentation = Data.getCStr(&Offset);
    477       uint8_t AddressSize = Version < 4 ? Data.getAddressSize() : Data.getU8(&Offset);
    478       Data.setAddressSize(AddressSize);
    479       uint8_t SegmentDescriptorSize = Version < 4 ? 0 : Data.getU8(&Offset);
    480       uint64_t CodeAlignmentFactor = Data.getULEB128(&Offset);
    481       int64_t DataAlignmentFactor = Data.getSLEB128(&Offset);
    482       uint64_t ReturnAddressRegister = Data.getULEB128(&Offset);
    483 
    484       auto Cie = make_unique<CIE>(StartOffset, Length, Version,
    485                                   StringRef(Augmentation), AddressSize,
    486                                   SegmentDescriptorSize, CodeAlignmentFactor,
    487                                   DataAlignmentFactor, ReturnAddressRegister);
    488       CIEs[StartOffset] = Cie.get();
    489       Entries.emplace_back(std::move(Cie));
    490     } else {
    491       // FDE
    492       uint64_t CIEPointer = Id;
    493       uint64_t InitialLocation = Data.getAddress(&Offset);
    494       uint64_t AddressRange = Data.getAddress(&Offset);
    495 
    496       Entries.emplace_back(new FDE(StartOffset, Length, CIEPointer,
    497                                    InitialLocation, AddressRange,
    498                                    CIEs[CIEPointer]));
    499     }
    500 
    501     Entries.back()->parseInstructions(Data, &Offset, EndStructureOffset);
    502 
    503     if (Offset != EndStructureOffset) {
    504       std::string Str;
    505       raw_string_ostream OS(Str);
    506       OS << format("Parsing entry instructions at %lx failed", StartOffset);
    507       report_fatal_error(Str);
    508     }
    509   }
    510 }
    511 
    512 
    513 void DWARFDebugFrame::dump(raw_ostream &OS) const {
    514   OS << "\n";
    515   for (const auto &Entry : Entries) {
    516     Entry->dumpHeader(OS);
    517     Entry->dumpInstructions(OS);
    518     OS << "\n";
    519   }
    520 }
    521 
    522