[llvm-objdump] Add frame register opcode to variable display

[ostannard]

Summary

The DW_OP_fbreg opcode references an expression stored in the DW_AT_frame_base attribute of the function, so we need to pass that through to the expression printer, and build it in the unit test.

[jhenderson]

I don't think I'm in a good position to review most of this code. I've commented on a few things, but somebody else should do the rest.

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

9

clang-format the header include list. This is the wrong place for this line.

430

Is it possible to hit this assertion if you are using malformed DWARF?

437

clang-fomat needed on this new code.

llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp

59–61

I'm going to guess that this won't work in a non-ARM build of LLVM...

You probably just want to return if this creation fails.

79

uint32_t seems like an odd type for a number of things. I'd expect size_t.

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

 #define LLVM_DEBUGINFO_DWARFEXPRESSION_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/DataExtractor.h"
 
 namespace llvm {
+class DWARFDie;
 class DWARFUnit;
 class MCRegisterInfo;
 class raw_ostream;
 
 class DWARFExpression {
 public:
   class iterator;
 
public:
 
   void print(raw_ostream &OS, const MCRegisterInfo *RegInfo, DWARFUnit *U,
              bool IsEH = false) const;
 
   /// Print the expression in a format intended to be compact and useful to a
   /// user, but not perfectly unambiguous, or capable of representing every
   /// valid DWARF expression. Returns true if the expression was sucessfully
   /// printed.
-  bool printCompact(raw_ostream &OS, const MCRegisterInfo &RegInfo);
+  bool printCompact(raw_ostream &OS, const MCRegisterInfo &RegInfo,
+                    const DWARFDie FuncDie);
 
   bool verify(DWARFUnit *U);
 
 private:
   DataExtractor Data;
   uint8_t AddressSize;
 };
 

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

 //===-- DWARFExpression.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/Support/Format.h"
 #include <cassert>
 #include <cstdint>
 #include <vector>
 
 using namespace llvm;
 using namespace dwarf;
struct PrintedExpr {
   ExprKind Kind;
   SmallString<16> String;
 
   PrintedExpr(ExprKind K = Address) : Kind(K) {}
 };
 
 static bool printCompactDWARFExpr(raw_ostream &OS, DWARFExpression::iterator I,
                                   const DWARFExpression::iterator E,
-                                  const MCRegisterInfo &MRI) {
+                                  const MCRegisterInfo &MRI,
+                                  const DWARFDie FuncDie = DWARFDie()) {
   SmallVector<PrintedExpr, 4> Stack;
 
   while (I != E) {
     DWARFExpression::Operation &Op = *I;
     uint8_t Opcode = Op.getCode();
     switch (Opcode) {
     case dwarf::DW_OP_regx: {
       // DW_OP_regx: A register, with the register num given as an operand.
while (I != E) {
     case dwarf::DW_OP_GNU_entry_value: {
       // DW_OP_entry_value contains a sub-expression which must be rendered
       // separately.
       uint64_t SubExprLength = Op.getRawOperand(0);
       DWARFExpression::iterator SubExprEnd = I.skipBytes(SubExprLength);
       ++I;
       raw_svector_ostream S(Stack.emplace_back().String);
       S << "entry(";
-      printCompactDWARFExpr(S, I, SubExprEnd, MRI);
+      printCompactDWARFExpr(S, I, SubExprEnd, MRI, FuncDie);
       S << ")";
       I = SubExprEnd;
       continue;
     }
     case dwarf::DW_OP_stack_value: {
       // The top stack entry should be treated as the actual value of tne
       // variable, rather than the address of the variable in memory.
       assert(!Stack.empty());
       Stack.back().Kind = PrintedExpr::Value;
       break;
     }
+    case dwarf::DW_OP_fbreg: {
+      // Get the DW_AT_frame_base attribute from the function DIE and render
+      // that, plus an optional offset.
+      assert(FuncDie && "Cannot render DW_OP_fbreg without a function DIE");
+      raw_svector_ostream S(Stack.emplace_back().String);
+      if (Optional<DWARFFormValue> FrameBaseAttr =
+              FuncDie.find(dwarf::DW_AT_frame_base)) {
+        StringRef FrameBaseStr(
+            (const char *)FrameBaseAttr->getAsBlock()->data(),
+            FrameBaseAttr->getAsBlock()->size());
+        bool LittleEndian = FuncDie.getDwarfUnit()->getContext().isLittleEndian();
+        DataExtractor FrameBaseData(FrameBaseStr, LittleEndian, 0);
+        DWARFExpression FrameBaseExpr(
+            FrameBaseData, FuncDie.getDwarfUnit()->getAddressByteSize());
+        printCompactDWARFExpr(S, FrameBaseExpr.begin(), FrameBaseExpr.end(), MRI);
+      } else {
+        S << "<unknown frame base>";
+      }
+      int64_t Offset = Op.getRawOperand(0);
+      if (Offset)
+        S << format("%+" PRId64, Offset);
+
+      break;
+    }
     default:
       if (Opcode >= dwarf::DW_OP_reg0 && Opcode <= dwarf::DW_OP_reg31) {
         // DW_OP_reg<N>: A register, with the register num implied by the
         // opcode. Printed as the plain register name.
         uint64_t DwarfRegNum = Opcode - dwarf::DW_OP_reg0;
         Optional<unsigned> LLVMRegNum = MRI.getLLVMRegNum(DwarfRegNum, false);
         if (!LLVMRegNum) {
           OS << "<unknown register " << DwarfRegNum << ">";
default:
       }
       break;
     }
     ++I;
   }
 
   assert(Stack.size() == 1 && "expected one value on stack");
 
-  if (Stack.front().Kind == PrintedExpr::Address)
+  if (Stack.front().Kind == PrintedExpr::Address && FuncDie)
     OS << "[" << Stack.front().String << "]";
   else
     OS << Stack.front().String;
 
   return true;
 }
 
-bool DWARFExpression::printCompact(raw_ostream &OS, const MCRegisterInfo &MRI) {
-  return printCompactDWARFExpr(OS, begin(), end(), MRI);
+bool DWARFExpression::printCompact(raw_ostream &OS, const MCRegisterInfo &MRI,
+                                   const DWARFDie FuncDie) {
+  return printCompactDWARFExpr(OS, begin(), end(), MRI, FuncDie);
 }
 
 } // namespace llvm

llvm/tools/llvm-objdump/llvm-objdump.cpp

return LocExpr.Range->SectionIndex == Addr.SectionIndex &&
            LocExpr.Range->LowPC <= Addr.Address &&
            LocExpr.Range->HighPC > Addr.Address;
   }
 
   void print(raw_ostream &OS, const MCRegisterInfo &MRI) const {
     DataExtractor Data({LocExpr.Expr.data(), LocExpr.Expr.size()},
                        Unit->getContext().isLittleEndian(), 0);
     DWARFExpression Expression(Data, Unit->getAddressByteSize());
-    Expression.printCompact(OS, MRI);
+    Expression.printCompact(OS, MRI, FuncDie);
   }
 };
 
 /// Helper class for printing source variable locations alongside disassembly.
 class LiveVariablePrinter {
   // Information we want to track about one column in which we are printing a
   // variable live range.
   struct Column {

llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp

const Target *TheTarget =
         TargetRegistry::lookupTarget(TripleName, ErrorStr);
 
     if (!TheTarget)
       return;
 
     MRI.reset(TheTarget->createMCRegInfo(TripleName));
   }
 
-  void TestExprPrinter(ArrayRef<uint8_t> ExprData, StringRef Expected);
+  void TestExprPrinter(ArrayRef<uint8_t> ExprData, StringRef Expected,
+                       ArrayRef<uint8_t> FrameBaseExpr = {});
 };
 } // namespace
 
 void DWARFExpressionCompactPrinterTest::TestExprPrinter(
-    ArrayRef<uint8_t> ExprData, StringRef Expected) {
+    ArrayRef<uint8_t> ExprData, StringRef Expected,
+    ArrayRef<uint8_t> FrameBaseExpr) {
   // If we didn't build ARM, do not run the test.
   if (!MRI)
     return;
+  // Build a minimal DWARF tree containing a DW_TAG_subprogram with a
+  // DW_AT_frame_base attribute.
+  auto ExpectedDG =
+      dwarfgen::Generator::create(Triple("armv8a-linux-gnueabi"), 4);
+  ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
+  dwarfgen::Generator *DG = ExpectedDG.get().get();
+  {
+    dwarfgen::CompileUnit &CU = DG->addCompileUnit();
+    dwarfgen::DIE CUDie = CU.getUnitDIE();
+    dwarfgen::DIE FuncDie = CUDie.addChild(DW_TAG_subprogram);
+    FuncDie.addAttribute(DW_AT_frame_base, DW_FORM_block, FrameBaseExpr.data(),
+                         FrameBaseExpr.size());
+  }
+
+  // Write the DWARF tree to an in-memory ELF file.
+  StringRef FileBytes = DG->generate();
+  MemoryBufferRef FileBuffer(FileBytes, "dwarf");
+  auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
+  EXPECT_TRUE((bool)Obj);
+
+  // Parse the DWARF objects out of the ELF file.
+  std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
+  uint32_t NumCUs = DwarfContext->getNumCompileUnits();
+  EXPECT_EQ(NumCUs, 1u);
+  DWARFCompileUnit *U = cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0));
+  auto CUDie = U->getUnitDIE(false);
+  EXPECT_TRUE(CUDie.isValid());
+  DWARFDie FuncDie = CUDie.getFirstChild();
+  EXPECT_TRUE(FuncDie.isValid());
 
   // Print the expression, passing in the subprogram DIE, and check that the
   // result is as expected.
   std::string Result;
   raw_string_ostream OS(Result);
   DataExtractor DE(ExprData, true, 8);
   DWARFExpression Expr(DE, 8);
-  Expr.printCompact(OS, *MRI);
+  Expr.printCompact(OS, *MRI, FuncDie);
   EXPECT_EQ(OS.str(), Expected);
 }
 
 TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_reg0) {
   TestExprPrinter({DW_OP_reg0}, "R0");
 }
 
 TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_reg10) {
TestExprPrinter({DW_OP_entry_value, 0x01, DW_OP_reg0, DW_OP_stack_value},
                   "entry(R0)");
 }
 
 TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_entry_value_mem) {
   TestExprPrinter(
       {DW_OP_entry_value, 0x02, DW_OP_breg13, 0x10, DW_OP_stack_value},
       "entry([SP+16])");
 }
+
+TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_fbreg) {
+  TestExprPrinter({DW_OP_fbreg, 0x8}, "[R11+8]", {DW_OP_reg11});
+}