[lldb] Change some pointers to refs in register printing code

[DavidSpickett]

Summary

No one was passing nullptr for these.

[JDevlieghere]

LGTM

lldb/include/lldb/Core/DumpRegisterValue.h

 class RegisterValue;
 struct RegisterInfo;
 class Stream;
 
 // The default value of 0 for reg_name_right_align_at means no alignment at
 // all.
 // Set print_flags to true to print register fields if they are available.
 // If you do so, target_sp must be non-null for it to work.
-void DumpRegisterValue(const RegisterValue &reg_val, Stream *s,
-                       const RegisterInfo *reg_info, bool prefix_with_name,
+void 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,
                        ExecutionContextScope *exe_scope = nullptr,
                        bool print_flags = false,
                        lldb::TargetSP target_sp = nullptr);
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_DUMPREGISTERVALUE_H

lldb/source/Commands/CommandObjectRegister.cpp

HandleArgumentCompletion(CompletionRequest &request,
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eRegisterCompletion,
         request, nullptr);
   }
 
   Options *GetOptions() override { return &m_option_group; }
 
   bool DumpRegister(const ExecutionContext &exe_ctx, Stream &strm,
-                    RegisterContext *reg_ctx, const RegisterInfo *reg_info,
+                    RegisterContext &reg_ctx, const RegisterInfo &reg_info,
                     bool print_flags) {
-    if (reg_info) {
-      RegisterValue reg_value;
+    if (!reg_ctx.ReadRegister(&reg_info, reg_value))
+      return false;
 
-      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;
-        DumpRegisterValue(reg_value, &strm, reg_info, prefix_with_name,
-                          prefix_with_altname, m_format_options.GetFormat(), 8,
-                          exe_ctx.GetBestExecutionContextScope(), print_flags,
-                          exe_ctx.GetTargetSP());
-        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()
-                      .GetSectionLoadList()
-                      .ResolveLoadAddress(reg_addr, so_reg_addr)) {
-                strm.PutCString("  ");
-                so_reg_addr.Dump(&strm, exe_ctx.GetBestExecutionContextScope(),
-                                 Address::DumpStyleResolvedDescription);
-              }
-            }
-          }
-        }
-        strm.EOL();
-        return true;
-      }
-    }
-    return false;
-  }
+    DumpRegisterValue(reg_value, strm, reg_info, prefix_with_name,
+    if ((reg_info.encoding == eEncodingUint) ||
+        (reg_info.encoding == eEncodingSint)) {
+      if (process && reg_info.byte_size == process->GetAddressByteSize()) {
+          if (exe_ctx.GetTargetRef().GetSectionLoadList().ResolveLoadAddress(
+                  reg_addr, so_reg_addr)) {
 
   bool DumpRegisterSet(const ExecutionContext &exe_ctx, Stream &strm,
                        RegisterContext *reg_ctx, size_t set_idx,
                        bool primitive_only = false) {
     uint32_t unavailable_count = 0;
     uint32_t available_count = 0;
 
     if (!reg_ctx)
       return false; // thread has no registers (i.e. core files are corrupt,
                     // incomplete crash logs...)
 
     const RegisterSet *const reg_set = reg_ctx->GetRegisterSet(set_idx);
     if (reg_set) {
       strm.Printf("%s:\n", (reg_set->name ? reg_set->name : "unknown"));
       strm.IndentMore();
       const size_t num_registers = reg_set->num_registers;
       for (size_t reg_idx = 0; reg_idx < num_registers; ++reg_idx) {
         const uint32_t reg = reg_set->registers[reg_idx];
         const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg);
         // Skip the dumping of derived register if primitive_only is true.
         if (primitive_only && reg_info && reg_info->value_regs)
           continue;
 
-        if (DumpRegister(exe_ctx, strm, reg_ctx, reg_info,
+        if (reg_info && DumpRegister(exe_ctx, strm, *reg_ctx, *reg_info,
                                      /*print_flags=*/false))
           ++available_count;
         else
           ++unavailable_count;
       }
       strm.IndentLess();
       if (unavailable_count) {
         strm.Indent();
         strm.Printf("%u registers were unavailable.\n", unavailable_count);
       }
       strm.EOL();
     }
     return available_count > 0;
   }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Stream &strm = result.GetOutputStream();
     RegisterContext *reg_ctx = m_exe_ctx.GetRegisterContext();
 
-    const RegisterInfo *reg_info = nullptr;
     if (command.GetArgumentCount() == 0) {
       size_t set_idx;
 
       size_t num_register_sets = 1;
       const size_t set_array_size = m_command_options.set_indexes.GetSize();
       if (set_array_size > 0) {
         for (size_t i = 0; i < set_array_size; ++i) {
           set_idx = m_command_options.set_indexes[i]->GetUInt64Value(UINT32_MAX,
if (command.GetArgumentCount() == 0) {
           // in most LLDB commands we accept $rbx as the name for register RBX
           // - and here we would reject it and non-existant. we should be more
           // consistent towards the user and allow them to say reg read $rbx -
           // internally, however, we should be strict and not allow ourselves
           // to call our registers $rbx in our own API
           auto arg_str = entry.ref();
           arg_str.consume_front("$");
 
-          reg_info = reg_ctx->GetRegisterInfoByName(arg_str);
-
-          if (reg_info) {
-            if (!DumpRegister(m_exe_ctx, strm, reg_ctx, reg_info,
+          if (const RegisterInfo *reg_info =
+                  reg_ctx->GetRegisterInfoByName(arg_str)) {
+            if (!DumpRegister(m_exe_ctx, strm, *reg_ctx, *reg_info,
                               /*print_flags=*/true))
               strm.Printf("%-12s = error: unavailable\n", reg_info->name);
           } else {
             result.AppendErrorWithFormat("Invalid register name '%s'.\n",
                                          arg_str.str().c_str());
           }
         }
       }

lldb/source/Core/DumpRegisterValue.cpp

lldb_private::DumpValueObjectOptions::ChildPrintingDecider decider =
         // Unnamed bit-fields are padding that we don't want to show.
         return varname.GetLength();
       };
   dump_options.SetChildPrintingDecider(decider).SetHideRootType(true);
 
   vobj_sp->Dump(strm, dump_options);
 }
 
-void lldb_private::DumpRegisterValue(const RegisterValue &reg_val, Stream *s,
-                                     const RegisterInfo *reg_info,
+void 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,
                                      ExecutionContextScope *exe_scope,
                                      bool print_flags, TargetSP target_sp) {
   DataExtractor data;
   if (!reg_val.GetData(data))
     return;
 
   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 = std::string(format_string.GetString());
   if (prefix_with_name) {
-    if (reg_info->name) {
-      s->Printf(fmt.c_str(), reg_info->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);
+    } 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);
+      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);
+      s.Printf(fmt.c_str(), reg_info.name);
       name_printed = true;
     }
   }
   if (name_printed)
-    s->PutCString(" = ");
+    s.PutCString(" = ");
 
   if (format == eFormatDefault)
-    format = reg_info->format;
+    format = reg_info.format;
 
-  DumpDataExtractor(data, s,
+  DumpDataExtractor(data, &s,
                     0,                    // Offset in "data"
                     format,               // Format to use when dumping
-                    reg_info->byte_size,  // item_byte_size
+                    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
                     exe_scope);
 
-  if (!print_flags || !reg_info->flags_type || !exe_scope || !target_sp ||
-      (reg_info->byte_size != 4 && reg_info->byte_size != 8))
+  if (!print_flags || !reg_info.flags_type || !exe_scope || !target_sp ||
+      (reg_info.byte_size != 4 && reg_info.byte_size != 8))
     return;
 
   CompilerType fields_type = target_sp->GetRegisterType(
-      reg_info->name, *reg_info->flags_type, reg_info->byte_size);
+      reg_info.name, *reg_info.flags_type, reg_info.byte_size);
 
   // Use a new stream so we can remove a trailing newline later.
   StreamString fields_stream;
 
-  if (reg_info->byte_size == 4) {
-    dump_type_value(fields_type, reg_val.GetAsUInt32(), exe_scope, *reg_info,
+  if (reg_info.byte_size == 4) {
+    dump_type_value(fields_type, reg_val.GetAsUInt32(), exe_scope, reg_info,
                     fields_stream);
   } else {
-    dump_type_value(fields_type, reg_val.GetAsUInt64(), exe_scope, *reg_info,
+    dump_type_value(fields_type, reg_val.GetAsUInt64(), exe_scope, reg_info,
                     fields_stream);
   }
 
   // Registers are indented like:
   // (lldb) register read foo
   //     foo = 0x12345678
   // So we need to indent to match that.
 
   // First drop the extra newline that the value printer added. The register
   // command will add one itself.
   llvm::StringRef fields_str = fields_stream.GetString().drop_back();
 
   // End the line that contains "    foo = 0x12345678".
-  s->EOL();
+  s.EOL();
 
   // Then split the value lines and indent each one.
   bool first = true;
   while (fields_str.size()) {
     std::pair<llvm::StringRef, llvm::StringRef> split = fields_str.split('\n');
     fields_str = split.second;
     // Indent as far as the register name did.
-    s->Printf(fmt.c_str(), "");
+    s.Printf(fmt.c_str(), "");
 
     // Lines after the first won't have " = " so compensate for that.
     if (!first)
-      (*s) << "   ";
+      s << "   ";
     first = false;
 
-    (*s) << split.first;
+    s << split.first;
 
     // On the last line we don't want a newline because the command will add
     // one too.
     if (fields_str.size())
-      s->EOL();
+      s.EOL();
   }
 }

lldb/source/Core/EmulateInstruction.cpp

 
 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);
-  DumpRegisterValue(reg_value, &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/source/Core/FormatEntity.cpp

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)) {
-            DumpRegisterValue(reg_value, &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)) {
-          DumpRegisterValue(reg_value, &s, reg_info, false, false, format);
+          DumpRegisterValue(reg_value, s, *reg_info, false, false, format);
           return true;
         }
       }
     }
   }
   return false;
 }
 

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

bool UnwindAssemblyInstEmulation::ReadRegister(EmulateInstruction *instruction,
   Log *log = GetLog(LLDBLog::Unwind);
 
   if (log && log->GetVerbose()) {
 
     StreamString strm;
     strm.Printf("UnwindAssemblyInstEmulation::ReadRegister  (name = \"%s\") => "
                 "synthetic_value = %i, value = ",
                 reg_info->name, synthetic);
-    DumpRegisterValue(reg_value, &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 = GetLog(LLDBLog::Unwind);
 
   if (log && log->GetVerbose()) {
 
     StreamString strm;
     strm.Printf(
         "UnwindAssemblyInstEmulation::WriteRegister (name = \"%s\", value = ",
         reg_info->name);
-    DumpRegisterValue(reg_value, &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/source/Target/ThreadPlanCallFunction.cpp

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)) {
-        DumpRegisterValue(reg_value, &strm, reg_info, true, false,
+        DumpRegisterValue(reg_value, strm, *reg_info, true, false,
                           eFormatDefault);
         strm.EOL();
       }
     }
     log->PutString(strm.GetString());
   }
 }
 

lldb/source/Target/ThreadPlanTracer.cpp

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");
-          DumpRegisterValue(reg_value, stream, reg_info, true, false,
+          DumpRegisterValue(reg_value, *stream, *reg_info, true, false,
                             eFormatDefault);
         }
       }
       m_register_values[reg_num] = reg_value;
     }
   }
   stream->EOL();
   stream->Flush();
 }