Print operands of DWARF stack frame operations.

[keith.walker.arm]

Summary

Currently llvm-dwarfdump only displays the names of the DWARF stack frame operations.

This patch adds the printing of the operands to the stack frame operations.

Note that in this patch, register operands are reported using the DWARF register numbers and not the names of target registers.

[aprantl]

Hello Keith,

More llvm-dwarfdump features bring the potential for better test coverage: thanks!
Is there a particular reason for using a std::map over e.g., an llvm::DenseMap?

• adrian

[keith.walker.arm]

Adrian

More llvm-dwarfdump features bring the potential for better test

coverage: thanks!

Is there a particular reason for using a std::map over e.g., an

llvm::DenseMap?

No. It does look like I would be better using llvm:DenseMap here.

Keith

[keith.walker.arm]

This very old change never got committed (apologies to the reviewers) and the functionality has since been implement by friss in commit r230551

lib/DebugInfo/DWARFDebugFrame.cpp

 //===-- DWARFDebugFrame.h - Parsing of .debug_frame -------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFDebugFrame.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
+#include <map>
 #include <string>
 #include <vector>
 
 using namespace llvm;
 using namespace dwarf;
 
 
 /// \brief Abstract frame entry defining the common interface concrete
public:
   virtual void parseInstructions(uint32_t *Offset, uint32_t EndOffset);
 
   /// \brief Dump the entry header to the given output stream.
   virtual void dumpHeader(raw_ostream &OS) const = 0;
 
   /// \brief Dump the entry's instructions to the given output stream.
   virtual void dumpInstructions(raw_ostream &OS) const;
 
+  /// \brief Return the unsigned code alignment factor.
+  virtual uint64_t getCodeAlignmentFactor() const = 0;
+
+  /// \brief Return the signed data alignment factor.
+  virtual int64_t getDataAlignmentFactor() const = 0;
+
+  /// \brief Return address of the first instruction described by the frame.
+  virtual uint64_t getInitialLocation() const = 0;
+
 protected:
   const FrameKind Kind;
 
   /// \brief The data stream holding the section from which the entry was
   /// parsed.
   DataExtractor Data;
 
   /// \brief Offset of this entry in the section.
   uint64_t Offset;
 
   /// \brief Entry length as specified in DWARF.
   uint64_t Length;
 
   /// An entry may contain CFI instructions. An instruction consists of an
   /// opcode and an optional sequence of operands.
   typedef std::vector<uint64_t> Operands;
   struct Instruction {
     Instruction(uint8_t Opcode)
       : Opcode(Opcode)
     {}
 
+    uint64_t getUnsignedOperand(int index) const {
+      return Ops.at(index);
+    }
+
+    int64_t getSignedOperand(int index) const {
+      return (int64_t)Ops.at(index);
+    }
+
+    int32_t getRegisterOperand(int index) const {
+      return (int32_t)Ops.at(index);
+    }
+
     uint8_t Opcode;
     Operands Ops;
   };
 
   std::vector<Instruction> Instructions;
 
   /// Convenience methods to add a new instruction with the given opcode and
   /// operands to the Instructions vector.
   void addInstruction(uint8_t Opcode) {
     Instructions.push_back(Instruction(Opcode));
   }
 
   void addInstruction(uint8_t Opcode, uint64_t Operand1) {
     Instructions.push_back(Instruction(Opcode));
     Instructions.back().Ops.push_back(Operand1);
   }
 
   void addInstruction(uint8_t Opcode, uint64_t Operand1, uint64_t Operand2) {
     Instructions.push_back(Instruction(Opcode));
     Instructions.back().Ops.push_back(Operand1);
     Instructions.back().Ops.push_back(Operand2);
   }
+
+  /// Convenience method for printing register names
+  void printRegister(raw_ostream &OS, int dwarfRegNum) const {
+    // TODO: It would be nice to convert from dwarf register numbers
+    //       to actual target register names.
+    OS << "r" << dwarfRegNum;
+  }
+
 };
 
 
 // See DWARF standard v3, section 7.23
 const uint8_t DWARF_CFI_PRIMARY_OPCODE_MASK = 0xc0;
 const uint8_t DWARF_CFI_PRIMARY_OPERAND_MASK = 0x3f;
 
 
if (Primary) {
           addInstruction(Primary, Op1);
           break;
         case DW_CFA_offset:
           addInstruction(Primary, Op1, Data.getULEB128(Offset));
           break;
       }
     } else {
       // Extended opcode - its value is Opcode itself.
+      uint64_t Op1;
       switch (Opcode) {
         default: llvm_unreachable("Invalid extended CFI opcode");
         case DW_CFA_nop:
         case DW_CFA_remember_state:
         case DW_CFA_restore_state:
           // No operands
           addInstruction(Opcode);
           break;
if (Primary) {
           // Operands: SLEB128
           addInstruction(Opcode, Data.getSLEB128(Offset));
           break;
         case DW_CFA_offset_extended:
         case DW_CFA_register:
         case DW_CFA_def_cfa:
         case DW_CFA_val_offset:
           // Operands: ULEB128, ULEB128
-          addInstruction(Opcode, Data.getULEB128(Offset),
-                                 Data.getULEB128(Offset));
+          Op1 = Data.getULEB128(Offset); // ensure order of evaluation
+          addInstruction(Opcode, Op1, Data.getULEB128(Offset));
           break;
         case DW_CFA_offset_extended_sf:
         case DW_CFA_def_cfa_sf:
         case DW_CFA_val_offset_sf:
           // Operands: ULEB128, SLEB128
-          addInstruction(Opcode, Data.getULEB128(Offset),
-                                 Data.getSLEB128(Offset));
+          Op1 = Data.getULEB128(Offset); // ensure order of evaluation
+          addInstruction(Opcode, Op1, Data.getSLEB128(Offset));
           break;
         case DW_CFA_def_cfa_expression:
         case DW_CFA_expression:
         case DW_CFA_val_expression:
           // TODO: implement this
           report_fatal_error("Values with expressions not implemented yet!");
       }
     }
   }
 }
 
 
 void FrameEntry::dumpInstructions(raw_ostream &OS) const {
-  // TODO: at the moment only instruction names are dumped. Expand this to
-  // dump operands as well.
+  uint64_t Location = getInitialLocation();
+  uint64_t CodeAlignmentFactor = getCodeAlignmentFactor();
+  int64_t DataAlignmentFactor = getDataAlignmentFactor();
   for (std::vector<Instruction>::const_iterator I = Instructions.begin(),
                                                 E = Instructions.end();
        I != E; ++I) {
     uint8_t Opcode = I->Opcode;
     if (Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK)
       Opcode &= DWARF_CFI_PRIMARY_OPCODE_MASK;
-    OS << "  " << CallFrameString(Opcode) << ":\n";
+    OS << "  " << CallFrameString(Opcode) << ": ";
+    switch (Opcode) {
+      default: llvm_unreachable("Invalid extended CFI opcode");
+      case DW_CFA_nop:
+      case DW_CFA_remember_state:
+      case DW_CFA_restore_state:
+        // No operands
+        break;
+      case DW_CFA_set_loc:
+        Location = I->getUnsignedOperand(0);
+        // TODO: Need  better support for printing 64-bit addresses
+        OS << format ("0x%8.8" PRIx64, Location);
+        break;
+      case DW_CFA_advance_loc:
+      case DW_CFA_advance_loc1:
+      case DW_CFA_advance_loc2:
+      case DW_CFA_advance_loc4:
+        Location += I->getUnsignedOperand(0) * CodeAlignmentFactor;
+        // TODO: Need  better support for printing 64-bit addresses
+        OS << format("%" PRIu64 " to 0x%8.8" PRIx64,
+           I->getUnsignedOperand(0) * CodeAlignmentFactor, Location);
+        break;
+      case DW_CFA_def_cfa_offset:
+        OS << I->getUnsignedOperand(0);
+        break;
+      case DW_CFA_def_cfa_offset_sf:
+        OS << I->getSignedOperand(0) * DataAlignmentFactor;
+        break;
+      case DW_CFA_def_cfa:
+        printRegister(OS, I->getRegisterOperand(0));
+        OS << format(", %" PRIu64, I->getUnsignedOperand(1));
+        break;
+      case DW_CFA_def_cfa_sf:
+      case DW_CFA_val_offset_sf:
+        printRegister(OS, I->getRegisterOperand(0));
+        OS << format(", %" PRId64,
+            I->getSignedOperand(1) * DataAlignmentFactor);
+        break;
+      case DW_CFA_offset:
+      case DW_CFA_offset_extended:
+        printRegister(OS, I->getRegisterOperand(0));
+        OS << format(" at cfa%+" PRId64,
+            I->getUnsignedOperand(1) * DataAlignmentFactor);
+        break;
+      case DW_CFA_offset_extended_sf:
+        printRegister(OS, I->getRegisterOperand(0));
+        OS << format(" at cfa%+" PRId64,
+           I->getSignedOperand(1) * DataAlignmentFactor);
+        break;
+      case DW_CFA_val_offset:
+        printRegister(OS, I->getRegisterOperand(0));
+        OS << format(",%" PRId64,
+           I->getUnsignedOperand(1) * DataAlignmentFactor);
+        break;
+      case DW_CFA_def_cfa_register:
+      case DW_CFA_restore:
+      case DW_CFA_restore_extended:
+      case DW_CFA_same_value:
+      case DW_CFA_undefined:
+        printRegister(OS, I->getRegisterOperand(0));
+        break;
+      case DW_CFA_register:
+        printRegister(OS, I->getRegisterOperand(0));
+        OS << ",";
+        printRegister(OS, I->getRegisterOperand(1));
+        break;
+      case DW_CFA_def_cfa_expression:
+      case DW_CFA_expression:
+      case DW_CFA_val_expression:
+        // TODO: Not yet implemented in parseInstruction()
+        break;
+    }
+    OS << "\n";
   }
+
 }
 
 
 namespace {
 /// \brief DWARF Common Information Entry (CIE)
 class CIE : public FrameEntry {
 public:
   // CIEs (and FDEs) are simply container classes, so the only sensible way to
OS << format("  Code alignment factor: %u\n",
                  (uint32_t)CodeAlignmentFactor);
     OS << format("  Data alignment factor: %d\n",
                  (int32_t)DataAlignmentFactor);
     OS << format("  Return address column: %d\n",
                  (int32_t)ReturnAddressRegister);
     OS << "\n";
   }
 
+  uint64_t getCodeAlignmentFactor() const{
+    return CodeAlignmentFactor;
+  }
+
+  int64_t getDataAlignmentFactor() const {
+    return DataAlignmentFactor;
+  }
+
+  uint64_t getInitialLocation() const {
+    return 0; // A CIE does not really have a location
+  }
+
   static bool classof(const FrameEntry *FE) {
     return FE->getKind() == FK_CIE;
   } 
 
 private:
   /// The following fields are defined in section 6.4.1 of the DWARF standard v3
   uint8_t Version;
   SmallString<8> Augmentation;
   uint64_t CodeAlignmentFactor;
   int64_t DataAlignmentFactor;
   uint64_t ReturnAddressRegister;
 };
 
 
 /// \brief DWARF Frame Description Entry (FDE)
 class FDE : public FrameEntry {
 public:
-  // Each FDE has a CIE it's "linked to". Our FDE contains is constructed with
-  // an offset to the CIE (provided by parsing the FDE header). The CIE itself
-  // is obtained lazily once it's actually required.
+  // Each FDE has a CIE it's "linked to". Our FDE is constructed with
+  // an offset to the CIE (provided by parsing the FDE header). The CIE 
+  // is linked to after the FDE has been parsed.
   FDE(DataExtractor D, uint64_t Offset, uint64_t Length,
       int64_t LinkedCIEOffset, uint64_t InitialLocation, uint64_t AddressRange)
    : FrameEntry(FK_FDE, D, Offset, Length), LinkedCIEOffset(LinkedCIEOffset),
      InitialLocation(InitialLocation), AddressRange(AddressRange),
      LinkedCIE(NULL) {}
 
   ~FDE() {
   }
 
   void dumpHeader(raw_ostream &OS) const {
     OS << format("%08x %08x %08x FDE ",
                  (uint32_t)Offset, (uint32_t)Length, (int32_t)LinkedCIEOffset);
     OS << format("cie=%08x pc=%08x...%08x\n",
                  (int32_t)LinkedCIEOffset,
                  (uint32_t)InitialLocation,
                  (uint32_t)InitialLocation + (uint32_t)AddressRange);
-    if (LinkedCIE) {
-      OS << format("%p\n", LinkedCIE);
-    }
   }
 
   static bool classof(const FrameEntry *FE) {
     return FE->getKind() == FK_FDE;
   } 
+
+  void setLinkedCIE(CIE* Cie) {
+    LinkedCIE = Cie;
+  }
+
+  uint64_t getLinkedCIEOffset() const {
+    return LinkedCIEOffset;
+  }
+
+  uint64_t getCodeAlignmentFactor() const {
+    if (LinkedCIE)
+      return LinkedCIE->getCodeAlignmentFactor();
+    return 0;
+  }
+
+  int64_t getDataAlignmentFactor() const {
+    if (LinkedCIE)
+      return LinkedCIE->getDataAlignmentFactor();
+    return 0;
+  }
+
+  uint64_t getInitialLocation() const {
+    return InitialLocation;
+  }
+
 private:
 
   /// The following fields are defined in section 6.4.1 of the DWARF standard v3
   uint64_t LinkedCIEOffset;
   uint64_t InitialLocation;
   uint64_t AddressRange;
   CIE *LinkedCIE;
 };
for (int i = 0; i < Length; ++i) {
     errs().write_hex(c); errs() << " ";
   }
   errs() << "\n";
 }
 
 
 void DWARFDebugFrame::parse(DataExtractor Data) {
   uint32_t Offset = 0;
+  std::map<uint64_t,CIE*> CieMap;
 
   while (Data.isValidOffset(Offset)) {
     uint32_t StartOffset = Offset;
 
     bool IsDWARF64 = false;
     uint64_t Length = Data.getU32(&Offset);
     uint64_t Id;
 
if (IsCIE) {
       const char *Augmentation = Data.getCStr(&Offset);
       uint64_t CodeAlignmentFactor = Data.getULEB128(&Offset);
       int64_t DataAlignmentFactor = Data.getSLEB128(&Offset);
       uint64_t ReturnAddressRegister = Data.getULEB128(&Offset);
 
       Entry = new CIE(Data, StartOffset, Length, Version,
                       StringRef(Augmentation), CodeAlignmentFactor,
                       DataAlignmentFactor, ReturnAddressRegister);
+      CieMap[StartOffset] = (CIE*)Entry;
     } else {
       // FDE
       uint64_t CIEPointer = Id;
       uint64_t InitialLocation = Data.getAddress(&Offset);
       uint64_t AddressRange = Data.getAddress(&Offset);
 
       Entry = new FDE(Data, StartOffset, Length, CIEPointer,
                       InitialLocation, AddressRange);
     }
 
     assert(Entry && "Expected Entry to be populated with CIE or FDE");
     Entry->parseInstructions(&Offset, EndStructureOffset);
 
     if (Offset == EndStructureOffset) {
       // Entry instrucitons parsed successfully.
       Entries.push_back(Entry);
     } else {
       std::string Str;
       raw_string_ostream OS(Str);
       OS << format("Parsing entry instructions at %lx failed",
                    Entry->getOffset());
       report_fatal_error(Str);
     }
   }
+
+  // Fixup the FDE to CIE links
+  for (EntryVector::const_iterator I = Entries.begin(), E = Entries.end();
+       I != E; ++I) {
+    FrameEntry* Entry = *I;
+    if(Entry->getKind() == FrameEntry::FK_FDE) {
+      FDE* Fde = (FDE*)Entry;
+      uint64_t CieOffset = Fde->getLinkedCIEOffset();
+      std::map<uint64_t,CIE*>::iterator CI = CieMap.find(CieOffset);
+      if (CI != CieMap.end())
+        Fde->setLinkedCIE(CI->second);
+    }
+  }
 }
 
 
 void DWARFDebugFrame::dump(raw_ostream &OS) const {
   OS << "\n";
   for (EntryVector::const_iterator I = Entries.begin(), E = Entries.end();
        I != E; ++I) {
     FrameEntry *Entry = *I;
     Entry->dumpHeader(OS);
     Entry->dumpInstructions(OS);
     OS << "\n";
   }
 }
 

test/DebugInfo/dwarfdump-debug-frame-simple.test

 ; RUN: llvm-dwarfdump %p/Inputs/dwarfdump-test-32bit.elf.o -debug-dump=frames | FileCheck %s -check-prefix FRAMES
 ; Note: the input file was generated from Inputs/dwarfdump-test-32bit.elf.c
 
 ; FRAMES: .debug_frame
 ; FRAMES-NOT: .eh_frame
 
 ; FRAMES: 00000000 00000010 ffffffff CIE
 ; FRAMES: Version: 1
-; FRAMES:      DW_CFA_def_cfa
-; FRAMES-NEXT: DW_CFA_offset
+; FRAMES:      DW_CFA_def_cfa: r4, 4
+; FRAMES-NEXT: DW_CFA_offset: r8 at cfa-4
 ; FRAMES-NEXT: DW_CFA_nop
 ; FRAMES-NEXT: DW_CFA_nop
 
 ; FRAMES: 00000014 00000010 00000000 FDE cie=00000000 pc=00000000...00000022
-; FRAMES:      DW_CFA_advance_loc
-; FRAMES-NEXT: DW_CFA_def_cfa_offset
+; FRAMES:      DW_CFA_advance_loc: 3 to 0x00000003
+; FRAMES-NEXT: DW_CFA_def_cfa_offset: 12
 ; FRAMES-NEXT: DW_CFA_nop
 
 ; FRAMES: 00000028 00000014 00000000 FDE cie=00000000 pc=00000030...00000080
-; FRAMES:      DW_CFA_advance_loc
-; FRAMES-NEXT: DW_CFA_def_cfa_offset
-; FRAMES-NEXT: DW_CFA_offset
-; FRAMES-NEXT: DW_CFA_advance_loc
-; FRAMES-NEXT: DW_CFA_def_cfa_register
+; FRAMES:      DW_CFA_advance_loc: 1 to 0x00000031
+; FRAMES-NEXT: DW_CFA_def_cfa_offset: 8
+; FRAMES-NEXT: DW_CFA_offset: r5 at cfa-8
+; FRAMES-NEXT: DW_CFA_advance_loc: 2 to 0x00000033
+; FRAMES-NEXT: DW_CFA_def_cfa_register: r5
 
 ; FRAMES-NOT: CIE
 ; FRAMES-NOT: FDE