Move dumping code out of RegisterValue class

[labath]

Summary

The dump function was the only part of this class which depended on
high-level functionality. This was due to the DumpDataExtractor
function, which uses info from a running target to control dump format
(although, RegisterValue doesn't really use the high-level part of
DumpDataExtractor).

This patch follows the same approach done for the DataExtractor class,
and extracts the dumping code into a separate function/file. This file
can stay in the higher level code, while the RegisterValue class and
anything that does not depend in dumping can stay go to lower layers.

[labath]

Does anyone have an opinion on this?

[davide]

I guess this is fine. @jingham?

[zturner]

Seems good to me. Separating dump code from core logic is always helpful.

[clayborg]

Is this a case of keeping RegisterValue from needing to link against the stream stuff so code inside a directory doesn't depend on code from other directories? Not sure why we wouldn't want to just ask the object itself to dump itself...

[labath]

The Stream part isn't the problem. The problem is that the dumping code is implemented in terms of ExecutionContextScope, which then pulls in pretty much everything. If it was just the object "dumping itself" then I would be fine with it as a method, but here it's using the whole world to achieve that goal. At that point I would prefer it living in a separate place (though we can debate on whether it should be a completely separate file, or merged to a single file with the DumpDataExtractor code)

[jingham]

I don't agree that moving dump routines away from the class that they are dumping is a good idea in general. It makes it harder for somebody new to the code to find out how to print out the objects, which is often handy in development as well as for logging and the like. OTOH, it seems like in this case the motivation (RegisterValue is useful on the server side so its reducing its dependencies is desirable) outweighs these downsides.

If this pattern becomes more common, then we have to deal with how somebody would find these dump routines. If RegisterValue gets moved out of Core, would you really look to a file in Core for the dump routine, especially as many other classes have an obvious Dump method?

But this change is well motivated, so as a one-off this is okay.

[clayborg]

I am fine if this helps with not pulling in the world. Seems like it should move out of Core then no? Seems weird to make the change yet keep it in the same directory.

[labath]

In D48351#1168384, @jingham wrote:

If this pattern becomes more common, then we have to deal with how somebody would find these dump routines. If RegisterValue gets moved out of Core, would you really look to a file in Core for the dump routine, especially as many other classes have an obvious Dump method?

Do you think it would help if I merged this new file with the existing DumpDataExtractor.cpp into something like Core/Dumpers.h (I've considered something like that initially, but then chose not to in order to reduce rename churn). If there is a single file containing the dumping functions then it should just be a matter of knowing you need to look into that file. (OTOH, this way the files at least have the class name in them, so it's easier to find them by just browsing the source tree)

In D48351#1168453, @clayborg wrote:

I am fine if this helps with not pulling in the world. Seems like it should move out of Core then no? Seems weird to make the change yet keep it in the same directory.

The plan is to move RegisterValue (along with Scalar) into Utility as a follow-up. Right now I can't think of a better place than Core for the dumping functions as (at least in their current implementations) depend on pretty much everything.

[zturner]

I had previously thought of making a top level project called Dump that
depends on everything. Also makes it very obvious where all the dumpers
are. It can have overloaded functions called lldb_private::dump(T&) for
every value of T, then no matter what type you have, all you have to do is
call dump(T). Kills all birds with one stone

[labath]

Well, if it depends on everything, then it can only used from places
that also depend on everything. Right now I don't think it matters now
(though it will create a new Dump <-> "everything calling Dump"
cycle). However, I can imagine this might cause some tricky situations
later on when we try to clean up dependencies between the high level
classes.

[jingham]

Dump is really meant to be the private description of the object that you would use for logging and the like - Description was the public face of a class. So while the Description-like functionality could have a restrictions that constrain its use to pretty high up in the stack, you really want to be able to Dump some object you've been handed - particularly into the log stream - wherever that might help. So I don't think moving to restrict where you can use Dump is a good idea.

[labath]

In D48351#1169959, @jingham wrote:

Dump is really meant to be the private description of the object that you would use for logging and the like - Description was the public face of a class. So while the Description-like functionality could have a restrictions that constrain its use to pretty high up in the stack, you really want to be able to Dump some object you've been handed - particularly into the log stream - wherever that might help. So I don't think moving to restrict where you can use Dump is a good idea.

I fully agree with that. It should be easy to add a simple dump function for logging purposes which omits any fancy formatting that need higher level constructs to any object. It's just that the current dump function is used for both things: logging, and displaying information to the user. I can change the name to DescribeRegisterValue or something like that if you think that makes more sense.

lldb/trunk/include/lldb/Core/DumpRegisterValue.h

+//===-- DumpRegisterValue.h -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_CORE_DUMPREGISTERVALUE_H
+#define LLDB_CORE_DUMPREGISTERVALUE_H
+
+#include "lldb/lldb-enumerations.h"
+#include <cstdint>
+
+namespace lldb_private {
+
+class RegisterValue;
+struct RegisterInfo;
+class Stream;
+
+// The default value of 0 for reg_name_right_align_at means no alignment at
+// all.
+bool DumpRegisterValue(const RegisterValue &reg_val, Stream *s,
+                       const RegisterInfo *reg_info, bool prefix_with_name,
+                       bool prefix_with_alt_name, lldb::Format format,
+                       uint32_t reg_name_right_align_at = 0);
+
+} // namespace lldb_private
+
+#endif // LLDB_CORE_DUMPREGISTERVALUE_H

lldb/trunk/include/lldb/Core/RegisterValue.h

public:
   Status SetValueFromString(const RegisterInfo *reg_info,
                             llvm::StringRef value_str);
   Status SetValueFromString(const RegisterInfo *reg_info,
                             const char *value_str) = delete;
 
   Status SetValueFromData(const RegisterInfo *reg_info, DataExtractor &data,
                           lldb::offset_t offset, bool partial_data_ok);
 
-  // The default value of 0 for reg_name_right_align_at means no alignment at
-  // all.
-  bool Dump(Stream *s, const RegisterInfo *reg_info, bool prefix_with_name,
-            bool prefix_with_alt_name, lldb::Format format,
-            uint32_t reg_name_right_align_at = 0) const;
-
   const void *GetBytes() const;
 
   lldb::ByteOrder GetByteOrder() const {
     if (m_type == eTypeBytes)
       return buffer.byte_order;
     return endian::InlHostByteOrder();
   }
 

lldb/trunk/source/Commands/CommandObjectRegister.cpp

 //===-- CommandObjectRegister.cpp -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CommandObjectRegister.h"
 #include "lldb/Core/Debugger.h"
+#include "lldb/Core/DumpRegisterValue.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Scalar.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionGroupFormat.h"
 #include "lldb/Interpreter/OptionValueArray.h"
 #include "lldb/Interpreter/OptionValueBoolean.h"
bool DumpRegister(const ExecutionContext &exe_ctx, Stream &strm,
     if (reg_info) {
       RegisterValue reg_value;
 
       if (reg_ctx->ReadRegister(reg_info, reg_value)) {
         strm.Indent();
 
         bool prefix_with_altname = (bool)m_command_options.alternate_name;
         bool prefix_with_name = !prefix_with_altname;
-        reg_value.Dump(&strm, reg_info, prefix_with_name, prefix_with_altname,
-                       m_format_options.GetFormat(), 8);
+        DumpRegisterValue(reg_value, &strm, reg_info, prefix_with_name,
+                          prefix_with_altname, m_format_options.GetFormat(), 8);
         if ((reg_info->encoding == eEncodingUint) ||
             (reg_info->encoding == eEncodingSint)) {
           Process *process = exe_ctx.GetProcessPtr();
           if (process && reg_info->byte_size == process->GetAddressByteSize()) {
             addr_t reg_addr = reg_value.GetAsUInt64(LLDB_INVALID_ADDRESS);
             if (reg_addr != LLDB_INVALID_ADDRESS) {
               Address so_reg_addr;
               if (exe_ctx.GetTargetRef()

lldb/trunk/source/Core/CMakeLists.txt

add_lldb_library(lldbCore
   AddressResolver.cpp
   AddressResolverFileLine.cpp
   AddressResolverName.cpp
   Broadcaster.cpp
   Communication.cpp
   Debugger.cpp
   Disassembler.cpp
   DumpDataExtractor.cpp
+  DumpRegisterValue.cpp
   DynamicLoader.cpp
   EmulateInstruction.cpp
   Event.cpp
   FileLineResolver.cpp
   FileSpecList.cpp
   FormatEntity.cpp
   IOHandler.cpp
   Listener.cpp

lldb/trunk/source/Core/DumpRegisterValue.cpp

+//===-- DumpRegisterValue.cpp -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Core/DumpRegisterValue.h"
+#include "lldb/Core/DumpDataExtractor.h"
+#include "lldb/Core/RegisterValue.h"
+#include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/StreamString.h"
+#include "lldb/lldb-private-types.h"
+
+using namespace lldb;
+
+bool lldb_private::DumpRegisterValue(const RegisterValue &reg_val, Stream *s,
+                                     const RegisterInfo *reg_info,
+                                     bool prefix_with_name,
+                                     bool prefix_with_alt_name, Format format,
+                                     uint32_t reg_name_right_align_at) {
+  DataExtractor data;
+  if (reg_val.GetData(data)) {
+    bool name_printed = false;
+    // For simplicity, alignment of the register name printing applies only in
+    // the most common case where:
+    //
+    //     prefix_with_name^prefix_with_alt_name is true
+    //
+    StreamString format_string;
+    if (reg_name_right_align_at && (prefix_with_name ^ prefix_with_alt_name))
+      format_string.Printf("%%%us", reg_name_right_align_at);
+    else
+      format_string.Printf("%%s");
+    std::string fmt = format_string.GetString();
+    if (prefix_with_name) {
+      if (reg_info->name) {
+        s->Printf(fmt.c_str(), reg_info->name);
+        name_printed = true;
+      } else if (reg_info->alt_name) {
+        s->Printf(fmt.c_str(), reg_info->alt_name);
+        prefix_with_alt_name = false;
+        name_printed = true;
+      }
+    }
+    if (prefix_with_alt_name) {
+      if (name_printed)
+        s->PutChar('/');
+      if (reg_info->alt_name) {
+        s->Printf(fmt.c_str(), reg_info->alt_name);
+        name_printed = true;
+      } else if (!name_printed) {
+        // No alternate name but we were asked to display a name, so show the
+        // main name
+        s->Printf(fmt.c_str(), reg_info->name);
+        name_printed = true;
+      }
+    }
+    if (name_printed)
+      s->PutCString(" = ");
+
+    if (format == eFormatDefault)
+      format = reg_info->format;
+
+    DumpDataExtractor(data, s,
+                      0,                    // Offset in "data"
+                      format,               // Format to use when dumping
+                      reg_info->byte_size,  // item_byte_size
+                      1,                    // item_count
+                      UINT32_MAX,           // num_per_line
+                      LLDB_INVALID_ADDRESS, // base_addr
+                      0,                    // item_bit_size
+                      0);                   // item_bit_offset
+    return true;
+  }
+  return false;
+}

lldb/trunk/source/Core/EmulateInstruction.cpp

 //===-- EmulateInstruction.cpp ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/EmulateInstruction.h"
 
 #include "lldb/Core/Address.h"
+#include "lldb/Core/DumpRegisterValue.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"   // for StackFrame
 #include "lldb/Utility/ConstString.h" // for ConstString

 
 bool EmulateInstruction::WriteRegisterDefault(EmulateInstruction *instruction,
                                               void *baton,
                                               const Context &context,
                                               const RegisterInfo *reg_info,
                                               const RegisterValue &reg_value) {
   StreamFile strm(stdout, false);
   strm.Printf("    Write to Register (name = %s, value = ", reg_info->name);
-  reg_value.Dump(&strm, reg_info, false, false, eFormatDefault);
+  DumpRegisterValue(reg_value, &strm, reg_info, false, false, eFormatDefault);
   strm.PutCString(", context = ");
   context.Dump(strm, instruction);
   strm.EOL();
   return true;
 }
 
 void EmulateInstruction::Context::Dump(Stream &strm,
                                        EmulateInstruction *instruction) const {

lldb/trunk/source/Core/FormatEntity.cpp

 //===-- FormatEntity.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/FormatEntity.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h" // for AddressRange
 #include "lldb/Core/Debugger.h"
+#include "lldb/Core/DumpRegisterValue.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/RegisterValue.h" // for RegisterValue
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/FormatClasses.h" // for TypeNameSpecifier...
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/DataFormatters/TypeSummary.h" // for TypeSummaryImpl::...
if (reg_ctx) {
       const uint32_t lldb_reg_num =
           reg_ctx->ConvertRegisterKindToRegisterNumber(reg_kind, reg_num);
       if (lldb_reg_num != LLDB_INVALID_REGNUM) {
         const RegisterInfo *reg_info =
             reg_ctx->GetRegisterInfoAtIndex(lldb_reg_num);
         if (reg_info) {
           RegisterValue reg_value;
           if (reg_ctx->ReadRegister(reg_info, reg_value)) {
-            reg_value.Dump(&s, reg_info, false, false, format);
+            DumpRegisterValue(reg_value, &s, reg_info, false, false, format);
             return true;
           }
         }
       }
     }
   }
   return false;
 }
static bool DumpRegister(Stream &s, StackFrame *frame, const char *reg_name,
   if (frame) {
     RegisterContext *reg_ctx = frame->GetRegisterContext().get();
 
     if (reg_ctx) {
       const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName(reg_name);
       if (reg_info) {
         RegisterValue reg_value;
         if (reg_ctx->ReadRegister(reg_info, reg_value)) {
-          reg_value.Dump(&s, reg_info, false, false, format);
+          DumpRegisterValue(reg_value, &s, reg_info, false, false, format);
           return true;
         }
       }
     }
   }
   return false;
 }
 

lldb/trunk/source/Core/RegisterValue.cpp

 //===-- RegisterValue.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/RegisterValue.h"
 
-#include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Scalar.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-defines.h"       // for LLDB_INVALID_ADDRESS
 #include "lldb/lldb-private-types.h" // for RegisterInfo, type128
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 
 #include <cstdint> // for uint8_t, uint32_t, uint64_t
 #include <string>  // for string
 #include <tuple>   // for tie, tuple
 #include <vector>
 
 #include <assert.h>   // for assert
 #include <inttypes.h> // for PRIx64
 #include <stdio.h>    // for sscanf
 
 using namespace lldb;
 using namespace lldb_private;
 
-bool RegisterValue::Dump(Stream *s, const RegisterInfo *reg_info,
-                         bool prefix_with_name, bool prefix_with_alt_name,
-                         Format format,
-                         uint32_t reg_name_right_align_at) const {
-  DataExtractor data;
-  if (GetData(data)) {
-    bool name_printed = false;
-    // For simplicity, alignment of the register name printing applies only in
-    // the most common case where:
-    //
-    //     prefix_with_name^prefix_with_alt_name is true
-    //
-    StreamString format_string;
-    if (reg_name_right_align_at && (prefix_with_name ^ prefix_with_alt_name))
-      format_string.Printf("%%%us", reg_name_right_align_at);
-    else
-      format_string.Printf("%%s");
-    std::string fmt = format_string.GetString();
-    if (prefix_with_name) {
-      if (reg_info->name) {
-        s->Printf(fmt.c_str(), reg_info->name);
-        name_printed = true;
-      } else if (reg_info->alt_name) {
-        s->Printf(fmt.c_str(), reg_info->alt_name);
-        prefix_with_alt_name = false;
-        name_printed = true;
-      }
-    }
-    if (prefix_with_alt_name) {
-      if (name_printed)
-        s->PutChar('/');
-      if (reg_info->alt_name) {
-        s->Printf(fmt.c_str(), reg_info->alt_name);
-        name_printed = true;
-      } else if (!name_printed) {
-        // No alternate name but we were asked to display a name, so show the
-        // main name
-        s->Printf(fmt.c_str(), reg_info->name);
-        name_printed = true;
-      }
-    }
-    if (name_printed)
-      s->PutCString(" = ");
-
-    if (format == eFormatDefault)
-      format = reg_info->format;
-
-    DumpDataExtractor(data, s,
-                      0,                    // Offset in "data"
-                      format,               // Format to use when dumping
-                      reg_info->byte_size,  // item_byte_size
-                      1,                    // item_count
-                      UINT32_MAX,           // num_per_line
-                      LLDB_INVALID_ADDRESS, // base_addr
-                      0,                    // item_bit_size
-                      0);                   // item_bit_offset
-    return true;
-  }
-  return false;
-}
-
 bool RegisterValue::GetData(DataExtractor &data) const {
   return data.SetData(GetBytes(), GetByteSize(), GetByteOrder()) > 0;
 }
 
 uint32_t RegisterValue::GetAsMemoryData(const RegisterInfo *reg_info, void *dst,
                                         uint32_t dst_len,
                                         lldb::ByteOrder dst_byte_order,
                                         Status &error) const {

lldb/trunk/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp

 //===-- UnwindAssemblyInstEmulation.cpp --------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "UnwindAssemblyInstEmulation.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/DumpDataExtractor.h"
+#include "lldb/Core/DumpRegisterValue.h"
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataBufferHeap.h"
bool UnwindAssemblyInstEmulation::ReadRegister(EmulateInstruction *instruction,
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
 
   if (log && log->GetVerbose()) {
 
     StreamString strm;
     strm.Printf("UnwindAssemblyInstEmulation::ReadRegister  (name = \"%s\") => "
                 "synthetic_value = %i, value = ",
                 reg_info->name, synthetic);
-    reg_value.Dump(&strm, reg_info, false, false, eFormatDefault);
+    DumpRegisterValue(reg_value, &strm, reg_info, false, false, eFormatDefault);
     log->PutString(strm.GetString());
   }
   return true;
 }
 
 bool UnwindAssemblyInstEmulation::WriteRegister(
     EmulateInstruction *instruction, void *baton,
     const EmulateInstruction::Context &context, const RegisterInfo *reg_info,
bool UnwindAssemblyInstEmulation::WriteRegister(
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
 
   if (log && log->GetVerbose()) {
 
     StreamString strm;
     strm.Printf(
         "UnwindAssemblyInstEmulation::WriteRegister (name = \"%s\", value = ",
         reg_info->name);
-    reg_value.Dump(&strm, reg_info, false, false, eFormatDefault);
+    DumpRegisterValue(reg_value, &strm, reg_info, false, false, eFormatDefault);
     strm.PutCString(", context = ");
     context.Dump(strm, instruction);
     log->PutString(strm.GetString());
   }
 
   SetRegisterValue(*reg_info, reg_value);
 
   switch (context.type) {

lldb/trunk/source/Target/ThreadPlanCallFunction.cpp

 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Target/ThreadPlanCallFunction.h"
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Address.h"
+#include "lldb/Core/DumpRegisterValue.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
if (log && log->GetVerbose()) {
     log->PutCString(message);
 
     RegisterValue reg_value;
 
     for (uint32_t reg_idx = 0, num_registers = reg_ctx->GetRegisterCount();
          reg_idx < num_registers; ++reg_idx) {
       const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_idx);
       if (reg_ctx->ReadRegister(reg_info, reg_value)) {
-        reg_value.Dump(&strm, reg_info, true, false, eFormatDefault);
+        DumpRegisterValue(reg_value, &strm, reg_info, true, false,
+                          eFormatDefault);
         strm.EOL();
       }
     }
     log->PutString(strm.GetString());
   }
 }
 
 void ThreadPlanCallFunction::DoTakedown(bool success) {

lldb/trunk/source/Target/ThreadPlanTracer.cpp

 //===-- ThreadPlanTracer.cpp ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 #include <cstring>
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Disassembler.h"
+#include "lldb/Core/DumpRegisterValue.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/Process.h"
for (uint32_t reg_num = 0, num_registers = reg_ctx->GetRegisterCount();
        reg_num < num_registers; ++reg_num) {
     const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_num);
     if (reg_ctx->ReadRegister(reg_info, reg_value)) {
       assert(reg_num < m_register_values.size());
       if (m_register_values[reg_num].GetType() == RegisterValue::eTypeInvalid ||
           reg_value != m_register_values[reg_num]) {
         if (reg_value.GetType() != RegisterValue::eTypeInvalid) {
           stream->PutCString("\n\t");
-          reg_value.Dump(stream, reg_info, true, false, eFormatDefault);
+          DumpRegisterValue(reg_value, stream, reg_info, true, false,
+                            eFormatDefault);
         }
       }
       m_register_values[reg_num] = reg_value;
     }
   }
   stream->EOL();
   stream->Flush();
 }