[llvm-objdump] Add simple memory expressions to variable display

[ostannard]

Summary

This adds the DW_OP_breg0..DW_OP_breg31 and DW_OP_bregx opcodes to the DWARF expression printer, so we can display locations for source variables which are in memory.

[aprantl]

llvm/test/tools/llvm-objdump/ARM/debug-vars-breg.s

1 ↗

(On Diff #245419)

Same comment as applies as in the other review. Could this be tested with a unittest that just dumps a single expression?

[ostannard]

Convert expression printing test to unit tests. Thanks for the suggestion, this is a much neater way to test this.

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

case dwarf::DW_OP_regx: {
       if (!LLVMRegNum) {
         OS << "<unknown register " << DwarfRegNum << ">";
         return false;
       }
       raw_svector_ostream S(Stack.emplace_back(PrintedExpr::Value).String);
       S << MRI.getName(*LLVMRegNum);
       break;
     }
+    case dwarf::DW_OP_bregx: {
+      int DwarfRegNum = Op.getRawOperand(0);
+      int64_t Offset = Op.getRawOperand(1);
+      Optional<unsigned> LLVMRegNum = MRI.getLLVMRegNum(DwarfRegNum, false);
+      if (!LLVMRegNum) {
+        OS << "<unknown register " << DwarfRegNum << ">";
+        return false;
+      }
+      raw_svector_ostream S(Stack.emplace_back().String);
+      S << MRI.getName(*LLVMRegNum);
+      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 << ">";
           return false;
         }
         raw_svector_ostream S(Stack.emplace_back(PrintedExpr::Value).String);
         S << MRI.getName(*LLVMRegNum);
+      } else if (Opcode >= dwarf::DW_OP_breg0 &&
+                 Opcode <= dwarf::DW_OP_breg31) {
+        int DwarfRegNum = Opcode - dwarf::DW_OP_breg0;
+        int64_t Offset = Op.getRawOperand(0);
+        Optional<unsigned> LLVMRegNum = MRI.getLLVMRegNum(DwarfRegNum, false);
+        if (!LLVMRegNum) {
+          OS << "<unknown register " << DwarfRegNum << ">";
+          return false;
+        }
+        raw_svector_ostream S(Stack.emplace_back().String);
+        S << MRI.getName(*LLVMRegNum);
+        if (Offset)
+          S << format("%+" PRId64, Offset);
       } else {
         // If we hit an unknown operand, we don't know its effect on the stack,
         // so bail out on the whole expression.
         OS << "<unknown op " << dwarf::OperationEncodingString(Opcode) << " ("
            << (int)Opcode << ")>";
         return false;
       }
       break;
     }
     ++I;
   }
 
   assert(Stack.size() == 1 && "expected one value on stack");
+
+  if (Stack.front().Kind == PrintedExpr::Address)
+    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);
 }
 
 } // namespace llvm

llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp

 
 TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_reg10) {
   TestExprPrinter({DW_OP_reg10}, "R10");
 }
 
 TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_regx) {
   TestExprPrinter({DW_OP_regx, 0x80, 0x02}, "D0");
 }
+
+TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_breg0) {
+  TestExprPrinter({DW_OP_breg0, 0x04}, "[R0+4]");
+}
+
+TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_breg0_large_offset) {
+  TestExprPrinter({DW_OP_breg0, 0x80, 0x02}, "[R0+256]");
+}
+
+TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_breg13) {
+  TestExprPrinter({DW_OP_breg13, 0x10}, "[SP+16]");
+}
+
+TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_breg13_zero_offset) {
+  TestExprPrinter({DW_OP_breg13, 0x00}, "[SP]");
+}
+
+TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_breg0_negative) {
+  TestExprPrinter({DW_OP_breg0, 0x70}, "[R0-16]");
+}
+
+TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_bregx) {
+  TestExprPrinter({DW_OP_bregx, 0x0d, 0x28}, "[SP+40]");
+}