[lldb][NFC] Move Address and AddressRange functions out of Stream and let them take raw_ostream

[teemperor]

Summary

Yet another step on the long road towards getting rid of lldb's Stream class.

We probably should just make this some kind of member of Address/AddressRange, but it seems quite often we just push
in random integers in there and this is just about getting rid of Stream and not improving arbitrary APIs.

I had to rename another DumpAddress function in FormatEntity that is dumping the content of an address to make Clang happy.

[labath]

All our namespace names are snake_case, so this new namespace should be too. Though, honestly, I don't think this needs to be a namespace -- I'd probably just make the function names a bit more descriptive... Maybe DumpAddress/DumpAddressRange, to match the existing DumpRegisterValue/DumpDataExtractor ?

lldb/packages/Python/lldbsuite/test/commands/expression/import-std-module/vector-basic/TestBasicVector.py

23–53 ↗

(On Diff #232286)

huh ?

[teemperor]

• Removed unrelated change to std-vector test.
• Moved from namespace to Dump* prefix.
• Renamed some function in FormatEntity that already had that name and made Clang very unhappy.

[teemperor]

lldb/packages/Python/lldbsuite/test/commands/expression/import-std-module/vector-basic/TestBasicVector.py

23–53 ↗

(On Diff #232286)

Just checking if you actually look at my patches :)

[labath]

Let's ship it.

lldb/source/Utility/Stream.cpp

89

The "formatv" way of doing this would be via something like formatv("{0}0x{1:x}{2}", prefix, fmt_align(addr, AlignStyle::Right, addr_size*2, '0'), suffix), but that's quite a mouthful so I'd probably go for just s << prefix << format_hex(addr, 2+2*addr_size) << suffix;

[teemperor]

• Moved to format_hex.
• Removed a now failing part of StreamTest that tested printing an address on a 160 bit system (which LLDB doesn't support.... yet).

lldb/include/lldb/Utility/Stream.h

public:
   Stream &operator<<(uint16_t uval) = delete;
   Stream &operator<<(uint32_t uval) = delete;
   Stream &operator<<(uint64_t uval) = delete;
   Stream &operator<<(int8_t sval) = delete;
   Stream &operator<<(int16_t sval) = delete;
   Stream &operator<<(int32_t sval) = delete;
   Stream &operator<<(int64_t sval) = delete;
 
-  /// Output an address value to this stream.
-  ///
-  /// Put an address \a addr out to the stream with optional \a prefix and \a
-  /// suffix strings.
-  ///
-  /// \param[in] addr
-  ///     An address value.
-  ///
-  /// \param[in] addr_size
-  ///     Size in bytes of the address, used for formatting.
-  ///
-  /// \param[in] prefix
-  ///     A prefix C string. If nullptr, no prefix will be output.
-  ///
-  /// \param[in] suffix
-  ///     A suffix C string. If nullptr, no suffix will be output.
-  void Address(uint64_t addr, uint32_t addr_size, const char *prefix = nullptr,
-               const char *suffix = nullptr);
-
-  /// Output an address range to this stream.
-  ///
-  /// Put an address range \a lo_addr - \a hi_addr out to the stream with
-  /// optional \a prefix and \a suffix strings.
-  ///
-  /// \param[in] lo_addr
-  ///     The start address of the address range.
-  ///
-  /// \param[in] hi_addr
-  ///     The end address of the address range.
-  ///
-  /// \param[in] addr_size
-  ///     Size in bytes of the address, used for formatting.
-  ///
-  /// \param[in] prefix
-  ///     A prefix C string. If nullptr, no prefix will be output.
-  ///
-  /// \param[in] suffix
-  ///     A suffix C string. If nullptr, no suffix will be output.
-  void AddressRange(uint64_t lo_addr, uint64_t hi_addr, uint32_t addr_size,
-                    const char *prefix = nullptr, const char *suffix = nullptr);
-
   /// Output a C string to the stream.
   ///
   /// Print a C string \a cstr to the stream.
   ///
   /// \param[in] cstr
   ///     The string to be output to the stream.
   size_t PutCString(llvm::StringRef cstr);
 
protected:
 
   public:
     RawOstreamForward(Stream &target)
         : llvm::raw_ostream(/*unbuffered*/ true), m_target(target) {}
   };
   RawOstreamForward m_forwarder;
 };
 
+/// Output an address value to this stream.
+///
+/// Put an address \a addr out to the stream with optional \a prefix and \a
+/// suffix strings.
+///
+/// \param[in] s
+///     The output stream.
+///
+/// \param[in] addr
+///     An address value.
+///
+/// \param[in] addr_size
+///     Size in bytes of the address, used for formatting.
+///
+/// \param[in] prefix
+///     A prefix C string. If nullptr, no prefix will be output.
+///
+/// \param[in] suffix
+///     A suffix C string. If nullptr, no suffix will be output.
+void DumpAddress(llvm::raw_ostream &s, uint64_t addr, uint32_t addr_size,
+                 const char *prefix = nullptr, const char *suffix = nullptr);
+
+/// Output an address range to this stream.
+///
+/// Put an address range \a lo_addr - \a hi_addr out to the stream with
+/// optional \a prefix and \a suffix strings.
+///
+/// \param[in] s
+///     The output stream.
+///
+/// \param[in] lo_addr
+///     The start address of the address range.
+///
+/// \param[in] hi_addr
+///     The end address of the address range.
+///
+/// \param[in] addr_size
+///     Size in bytes of the address, used for formatting.
+///
+/// \param[in] prefix
+///     A prefix C string. If nullptr, no prefix will be output.
+///
+/// \param[in] suffix
+///     A suffix C string. If nullptr, no suffix will be output.
+void DumpAddressRange(llvm::raw_ostream &s, uint64_t lo_addr, uint64_t hi_addr,
+                      uint32_t addr_size, const char *prefix = nullptr,
+                      const char *suffix = nullptr);
+
 } // namespace lldb_private
 
 #endif // liblldb_Stream_h_

lldb/source/Core/Address.cpp

bool Address::Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style,
   case DumpStyleInvalid:
     return false;
 
   case DumpStyleSectionNameOffset:
     if (section_sp) {
       section_sp->DumpName(s);
       s->Printf(" + %" PRIu64, m_offset);
     } else {
-      s->Address(m_offset, addr_size);
+      DumpAddress(s->AsRawOstream(), m_offset, addr_size);
     }
     break;
 
   case DumpStyleSectionPointerOffset:
     s->Printf("(Section *)%p + ", static_cast<void *>(section_sp.get()));
-    s->Address(m_offset, addr_size);
+    DumpAddress(s->AsRawOstream(), m_offset, addr_size);
     break;
 
   case DumpStyleModuleWithFileAddress:
     if (section_sp) {
       ModuleSP module_sp = section_sp->GetModule();
       if (module_sp)
         s->Printf("%s[", module_sp->GetFileSpec().GetFilename().AsCString(
                              "<Unknown>"));
       else
         s->Printf("%s[", "<Unknown>");
     }
     LLVM_FALLTHROUGH;
   case DumpStyleFileAddress: {
     addr_t file_addr = GetFileAddress();
     if (file_addr == LLDB_INVALID_ADDRESS) {
       if (fallback_style != DumpStyleInvalid)
         return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
       return false;
     }
-    s->Address(file_addr, addr_size);
+    DumpAddress(s->AsRawOstream(), file_addr, addr_size);
     if (style == DumpStyleModuleWithFileAddress && section_sp)
       s->PutChar(']');
   } break;
 
   case DumpStyleLoadAddress: {
     addr_t load_addr = GetLoadAddress(target);
 
     /*
if (target) {
         load_addr = GetCallableLoadAddress(target);
     }
 
     if (load_addr == LLDB_INVALID_ADDRESS) {
       if (fallback_style != DumpStyleInvalid)
         return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
       return false;
     }
-    s->Address(load_addr, addr_size);
+    DumpAddress(s->AsRawOstream(), load_addr, addr_size);
   } break;
 
   case DumpStyleResolvedDescription:
   case DumpStyleResolvedDescriptionNoModule:
   case DumpStyleResolvedDescriptionNoFunctionArguments:
   case DumpStyleNoFunctionName:
     if (IsSectionOffset()) {
       uint32_t pointer_size = 4;
if (process) {
         if (dereferenced_load_addr != LLDB_INVALID_ADDRESS) {
           Address dereferenced_addr;
           if (dereferenced_addr.SetLoadAddress(dereferenced_load_addr,
                                                target)) {
             StreamString strm;
             if (dereferenced_addr.Dump(&strm, exe_scope,
                                        DumpStyleResolvedDescription,
                                        DumpStyleInvalid, addr_size)) {
-              s->Address(dereferenced_load_addr, addr_size, " -> ", " ");
+              DumpAddress(s->AsRawOstream(), dereferenced_load_addr, addr_size,
+                          " -> ", " ");
               s->Write(strm.GetString().data(), strm.GetSize());
               return true;
             }
           }
         }
       }
     }
     if (fallback_style != DumpStyleInvalid)

lldb/source/Core/AddressRange.cpp

bool AddressRange::Dump(Stream *s, Target *target, Address::DumpStyle style,
   switch (style) {
   default:
     break;
   case Address::DumpStyleSectionNameOffset:
   case Address::DumpStyleSectionPointerOffset:
     s->PutChar('[');
     m_base_addr.Dump(s, target, style, fallback_style);
     s->PutChar('-');
-    s->Address(m_base_addr.GetOffset() + GetByteSize(), addr_size);
+    DumpAddress(s->AsRawOstream(), m_base_addr.GetOffset() + GetByteSize(),
+                addr_size);
     s->PutChar(')');
     return true;
     break;
 
   case Address::DumpStyleModuleWithFileAddress:
     show_module = true;
     LLVM_FALLTHROUGH;
   case Address::DumpStyleFileAddress:
     vmaddr = m_base_addr.GetFileAddress();
     break;
 
   case Address::DumpStyleLoadAddress:
     vmaddr = m_base_addr.GetLoadAddress(target);
     break;
   }
 
   if (vmaddr != LLDB_INVALID_ADDRESS) {
     if (show_module) {
       ModuleSP module_sp(GetBaseAddress().GetModule());
       if (module_sp)
         s->Printf("%s", module_sp->GetFileSpec().GetFilename().AsCString(
                             "<Unknown>"));
     }
-    s->AddressRange(vmaddr, vmaddr + GetByteSize(), addr_size);
+    DumpAddressRange(s->AsRawOstream(), vmaddr, vmaddr + GetByteSize(),
+                     addr_size);
     return true;
   } else if (fallback_style != Address::DumpStyleInvalid) {
     return Dump(s, target, fallback_style, Address::DumpStyleInvalid);
   }
 
   return false;
 }
 

lldb/source/Core/DumpDataExtractor.cpp

case eFormatCString: {
           ++cstr;
         }
 
         s->PutChar('\"');
       }
     } break;
 
     case eFormatPointer:
-      s->Address(DE.GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
+      DumpAddress(s->AsRawOstream(),
+                  DE.GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
                                        item_bit_offset),
                   sizeof(addr_t));
       break;
 
     case eFormatComplexInteger: {
       size_t complex_int_byte_size = item_byte_size / 2;
 
       if (complex_int_byte_size > 0 && complex_int_byte_size <= 8) {
         s->Printf("%" PRIu64,
                   DE.GetMaxU64Bitfield(&offset, complex_int_byte_size, 0, 0));

lldb/source/Core/FormatEntity.cpp

if (script_interpreter) {
       } else {
         s.Printf("<error: %s>", error.AsCString());
       }
     }
   }
   return false;
 }
 
-static bool DumpAddress(Stream &s, const SymbolContext *sc,
-                        const ExecutionContext *exe_ctx, const Address &addr,
+static bool DumpAddressAndContent(Stream &s, const SymbolContext *sc,
+                                  const ExecutionContext *exe_ctx,
+                                  const Address &addr,
                                   bool print_file_addr_or_load_addr) {
   Target *target = Target::GetTargetFromContexts(exe_ctx, sc);
   addr_t vaddr = LLDB_INVALID_ADDRESS;
   if (exe_ctx && !target->GetSectionLoadList().IsEmpty())
     vaddr = addr.GetLoadAddress(target);
   if (vaddr == LLDB_INVALID_ADDRESS)
     vaddr = addr.GetFileAddress();
 
   if (vaddr != LLDB_INVALID_ADDRESS) {
bool FormatEntity::Format(const Entry &entry, Stream &s,
   case Entry::Type::VariableSynthetic:
   case Entry::Type::ScriptVariable:
   case Entry::Type::ScriptVariableSynthetic:
     return DumpValue(s, sc, exe_ctx, entry, valobj);
 
   case Entry::Type::AddressFile:
   case Entry::Type::AddressLoad:
   case Entry::Type::AddressLoadOrFile:
-    return (addr != nullptr && addr->IsValid() &&
-            DumpAddress(s, sc, exe_ctx, *addr,
+    return (
+        addr != nullptr && addr->IsValid() &&
+        DumpAddressAndContent(s, sc, exe_ctx, *addr,
                               entry.type == Entry::Type::AddressLoadOrFile));
 
   case Entry::Type::ProcessID:
     if (exe_ctx) {
       Process *process = exe_ctx->GetProcessPtr();
       if (process) {
         const char *format = "%" PRIu64;
         if (!entry.printf_format.empty())
           format = entry.printf_format.c_str();
case Entry::Type::FrameIndex:
     return false;
 
   case Entry::Type::FrameRegisterPC:
     if (exe_ctx) {
       StackFrame *frame = exe_ctx->GetFramePtr();
       if (frame) {
         const Address &pc_addr = frame->GetFrameCodeAddress();
         if (pc_addr.IsValid()) {
-          if (DumpAddress(s, sc, exe_ctx, pc_addr, false))
+          if (DumpAddressAndContent(s, sc, exe_ctx, pc_addr, false))
             return true;
         }
       }
     }
     return false;
 
   case Entry::Type::FrameRegisterSP:
     if (exe_ctx) {
bool FormatEntity::Format(const Entry &entry, Stream &s,
 
   case Entry::Type::LineEntryStartAddress:
   case Entry::Type::LineEntryEndAddress:
     if (sc && sc->line_entry.range.GetBaseAddress().IsValid()) {
       Address addr = sc->line_entry.range.GetBaseAddress();
 
       if (entry.type == Entry::Type::LineEntryEndAddress)
         addr.Slide(sc->line_entry.range.GetByteSize());
-      if (DumpAddress(s, sc, exe_ctx, addr, false))
+      if (DumpAddressAndContent(s, sc, exe_ctx, addr, false))
         return true;
     }
     return false;
 
   case Entry::Type::CurrentPCArrow:
     if (addr && exe_ctx && exe_ctx->GetFramePtr()) {
       RegisterContextSP reg_ctx =
           exe_ctx->GetFramePtr()->GetRegisterContextSP();

lldb/source/Expression/DWARFExpression.cpp

while (debug_loc_data.ValidOffset(offset)) {
     end_addr = debug_loc_data.GetMaxU64(&offset, addr_size);
 
     if (start_addr == 0 && end_addr == 0)
       break;
 
     s.PutCString("\n            ");
     s.Indent();
     if (cu)
-      s.AddressRange(start_addr + base_addr, end_addr + base_addr,
-                     cu->GetAddressByteSize(), nullptr, ": ");
+      DumpAddressRange(s.AsRawOstream(), start_addr + base_addr,
+                       end_addr + base_addr, cu->GetAddressByteSize(), nullptr,
+                       ": ");
     uint32_t loc_length = debug_loc_data.GetU16(&offset);
 
     DataExtractor locationData(debug_loc_data, offset, loc_length);
     PrintDWARFExpression(s, locationData, addr_size, 4, false);
     offset += loc_length;
   }
 }
 

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.cpp

while (
 
     s.Indent();
     if (begin == 0 && end == 0) {
       s.PutCString(" End");
       break;
     } else if (begin == LLDB_INVALID_ADDRESS) {
       // A base address selection entry
       base_addr = end;
-      s.Address(base_addr, sizeof(dw_addr_t), " Base address = ");
+      DumpAddress(s.AsRawOstream(), base_addr, sizeof(dw_addr_t),
+                  " Base address = ");
     } else {
       // Convert from offset to an address
       dw_addr_t begin_addr = begin + base_addr;
       dw_addr_t end_addr = end + base_addr;
 
-      s.AddressRange(begin_addr, end_addr, sizeof(dw_addr_t), nullptr);
+      DumpAddressRange(s.AsRawOstream(), begin_addr, end_addr,
+                       sizeof(dw_addr_t), nullptr);
     }
   }
 }
 
 bool DWARFDebugRanges::FindRanges(const DWARFUnit *cu,
                                   dw_offset_t debug_ranges_offset,
                                   DWARFRangeList &range_list) const {
   dw_addr_t debug_ranges_address = cu->GetRangesBase() + debug_ranges_offset;

lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

 }
 
 void DWARFFormValue::Dump(Stream &s) const {
   uint64_t uvalue = Unsigned();
   bool unit_relative_offset = false;
 
   switch (m_form) {
   case DW_FORM_addr:
-    s.Address(uvalue, sizeof(uint64_t));
+    DumpAddress(s.AsRawOstream(), uvalue, sizeof(uint64_t));
     break;
   case DW_FORM_flag:
   case DW_FORM_data1:
     s.PutHex8(uvalue);
     break;
   case DW_FORM_data2:
     s.PutHex16(uvalue);
     break;
if (dbg_str) {
       s.PutHex32(uvalue);
     }
   } break;
 
   case DW_FORM_ref_addr: {
     assert(m_unit); // Unit must be valid for DW_FORM_ref_addr objects or we
                     // will get this wrong
     if (m_unit->GetVersion() <= 2)
-      s.Address(uvalue, sizeof(uint64_t) * 2);
+      DumpAddress(s.AsRawOstream(), uvalue, sizeof(uint64_t) * 2);
     else
-      s.Address(uvalue, 4 * 2); // 4 for DWARF32, 8 for DWARF64, but we don't
-                                // support DWARF64 yet
+      DumpAddress(s.AsRawOstream(), uvalue,
+                  4 * 2); // 4 for DWARF32, 8 for DWARF64, but we don't
     break;
   }
   case DW_FORM_ref1:
     unit_relative_offset = true;
     break;
   case DW_FORM_ref2:
     unit_relative_offset = true;
     break;

lldb/source/Symbol/Block.cpp

if (target)
       base_addr =
           function->GetAddressRange().GetBaseAddress().GetLoadAddress(target);
     if (base_addr == LLDB_INVALID_ADDRESS)
       base_addr = function->GetAddressRange().GetBaseAddress().GetFileAddress();
 
     s->Printf(", range%s = ", num_ranges > 1 ? "s" : "");
     for (size_t i = 0; i < num_ranges; ++i) {
       const Range &range = m_ranges.GetEntryRef(i);
-      s->AddressRange(base_addr + range.GetRangeBase(),
+      DumpAddressRange(s->AsRawOstream(), base_addr + range.GetRangeBase(),
                        base_addr + range.GetRangeEnd(), 4);
     }
   }
 
   if (m_inlineInfoSP.get() != nullptr) {
     bool show_fullpaths = (level == eDescriptionLevelVerbose);
     m_inlineInfoSP->Dump(s, show_fullpaths);
   }
 }
if (!m_ranges.IsEmpty()) {
 
     size_t num_ranges = m_ranges.GetSize();
     for (size_t i = 0; i < num_ranges; ++i) {
       const Range &range = m_ranges.GetEntryRef(i);
       if (parent_block != nullptr && !parent_block->Contains(range))
         *s << '!';
       else
         *s << ' ';
-      s->AddressRange(base_addr + range.GetRangeBase(),
+      DumpAddressRange(s->AsRawOstream(), base_addr + range.GetRangeBase(),
                        base_addr + range.GetRangeEnd(), 4);
     }
   }
   s->EOL();
 
   if (depth > 0) {
     s->IndentMore();
 
     if (m_variable_list_sp.get()) {
void Block::DumpSymbolContext(Stream *s) {
   s->Printf(", Block{0x%8.8" PRIx64 "}", GetID());
 }
 
 void Block::DumpAddressRanges(Stream *s, lldb::addr_t base_addr) {
   if (!m_ranges.IsEmpty()) {
     size_t num_ranges = m_ranges.GetSize();
     for (size_t i = 0; i < num_ranges; ++i) {
       const Range &range = m_ranges.GetEntryRef(i);
-      s->AddressRange(base_addr + range.GetRangeBase(),
+      DumpAddressRange(s->AsRawOstream(), base_addr + range.GetRangeBase(),
                        base_addr + range.GetRangeEnd(), 4);
     }
   }
 }
 
 bool Block::Contains(addr_t range_offset) const {
   return m_ranges.FindEntryThatContains(range_offset) != nullptr;
 }
 

lldb/source/Target/ThreadPlanRunToAddress.cpp

if (num_addresses == 0) {
       s->Printf("run to address with no addresses given.");
       return;
     } else if (num_addresses == 1)
       s->Printf("run to address: ");
     else
       s->Printf("run to addresses: ");
 
     for (size_t i = 0; i < num_addresses; i++) {
-      s->Address(m_addresses[i], sizeof(addr_t));
+      DumpAddress(s->AsRawOstream(), m_addresses[i], sizeof(addr_t));
       s->Printf(" ");
     }
   } else {
     if (num_addresses == 0) {
       s->Printf("run to address with no addresses given.");
       return;
     } else if (num_addresses == 1)
       s->Printf("Run to address: ");
     else {
       s->Printf("Run to addresses: ");
     }
 
     for (size_t i = 0; i < num_addresses; i++) {
       if (num_addresses > 1) {
         s->Printf("\n");
         s->Indent();
       }
 
-      s->Address(m_addresses[i], sizeof(addr_t));
+      DumpAddress(s->AsRawOstream(), m_addresses[i], sizeof(addr_t));
       s->Printf(" using breakpoint: %d - ", m_break_ids[i]);
       Breakpoint *breakpoint =
           m_thread.CalculateTarget()->GetBreakpointByID(m_break_ids[i]).get();
       if (breakpoint)
         breakpoint->Dump(s);
       else
         s->Printf("but the breakpoint has been deleted.");
     }
bool ThreadPlanRunToAddress::ValidatePlan(Stream *error) {
   // If we couldn't set the breakpoint for some reason, then this won't work.
   bool all_bps_good = true;
   size_t num_break_ids = m_break_ids.size();
   for (size_t i = 0; i < num_break_ids; i++) {
     if (m_break_ids[i] == LLDB_INVALID_BREAK_ID) {
       all_bps_good = false;
       if (error) {
         error->Printf("Could not set breakpoint for address: ");
-        error->Address(m_addresses[i], sizeof(addr_t));
+        DumpAddress(error->AsRawOstream(), m_addresses[i], sizeof(addr_t));
         error->Printf("\n");
       }
     }
   }
   return all_bps_good;
 }
 
 bool ThreadPlanRunToAddress::DoPlanExplainsStop(Event *event_ptr) {

lldb/source/Target/ThreadPlanStepInRange.cpp

void ThreadPlanStepInRange::GetDescription(Stream *s,
   s->PutChar('.');
 }
 
 bool ThreadPlanStepInRange::ShouldStop(Event *event_ptr) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
   if (log) {
     StreamString s;
-    s.Address(
-        m_thread.GetRegisterContext()->GetPC(),
+    DumpAddress(
+        s.AsRawOstream(), m_thread.GetRegisterContext()->GetPC(),
         m_thread.CalculateTarget()->GetArchitecture().GetAddressByteSize());
     LLDB_LOGF(log, "ThreadPlanStepInRange reached %s.", s.GetData());
   }
 
   if (IsPlanComplete())
     return true;
 
   m_no_more_plans = false;

lldb/source/Target/ThreadPlanStepInstruction.cpp

if (level == lldb::eDescriptionLevelBrief) {
     if (m_step_over)
       s->Printf("instruction step over");
     else
       s->Printf("instruction step into");
 
     PrintFailureIfAny();
   } else {
     s->Printf("Stepping one instruction past ");
-    s->Address(m_instruction_addr, sizeof(addr_t));
+    DumpAddress(s->AsRawOstream(), m_instruction_addr, sizeof(addr_t));
     if (!m_start_has_symbol)
       s->Printf(" which has no symbol");
 
     if (m_step_over)
       s->Printf(" stepping over calls");
     else
       s->Printf(" stepping into calls");
 
if (cur_frame_zero_id == m_stack_id || m_stack_id < cur_frame_zero_id) {
             }
           }
 
           if (log) {
             StreamString s;
             s.PutCString("Stepped in to: ");
             addr_t stop_addr =
                 m_thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC();
-            s.Address(stop_addr, m_thread.CalculateTarget()
-                                     ->GetArchitecture()
-                                     .GetAddressByteSize());
+            DumpAddress(s.AsRawOstream(), stop_addr,
+                        m_thread.CalculateTarget()
             s.PutCString(" stepping out to: ");
             addr_t return_addr = return_frame->GetRegisterContext()->GetPC();
-            s.Address(return_addr, m_thread.CalculateTarget()
-                                       ->GetArchitecture()
-                                       .GetAddressByteSize());
+            DumpAddress(s.AsRawOstream(), return_addr,
+                        m_thread.CalculateTarget()
             LLDB_LOGF(log, "%s.", s.GetData());
           }
 
           // StepInstruction should probably have the tri-state RunMode, but
           // for now it is safer to run others.
           const bool stop_others = false;
           m_thread.QueueThreadPlanForStepOutNoShouldStop(
               false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion, 0,

lldb/source/Target/ThreadPlanStepOverRange.cpp

bool ThreadPlanStepOverRange::IsEquivalentContext(
   return m_addr_context.symbol && m_addr_context.symbol == context.symbol;
 }
 
 bool ThreadPlanStepOverRange::ShouldStop(Event *event_ptr) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
   if (log) {
     StreamString s;
-    s.Address(
-        m_thread.GetRegisterContext()->GetPC(),
+    DumpAddress(
+        s.AsRawOstream(), m_thread.GetRegisterContext()->GetPC(),
         m_thread.CalculateTarget()->GetArchitecture().GetAddressByteSize());
     LLDB_LOGF(log, "ThreadPlanStepOverRange reached %s.", s.GetData());
   }
 
   // If we're out of the range but in the same frame or in our caller's frame
   // then we should stop. When stepping out we only stop others if we are
   // forcing running one thread.
   bool stop_others = (m_stop_others == lldb::eOnlyThisThread);

lldb/source/Target/ThreadPlanStepThrough.cpp

 }
 
 void ThreadPlanStepThrough::GetDescription(Stream *s,
                                            lldb::DescriptionLevel level) {
   if (level == lldb::eDescriptionLevelBrief)
     s->Printf("Step through");
   else {
     s->PutCString("Stepping through trampoline code from: ");
-    s->Address(m_start_address, sizeof(addr_t));
+    DumpAddress(s->AsRawOstream(), m_start_address, sizeof(addr_t));
     if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID) {
       s->Printf(" with backstop breakpoint ID: %d at address: ",
                 m_backstop_bkpt_id);
-      s->Address(m_backstop_addr, sizeof(addr_t));
+      DumpAddress(s->AsRawOstream(), m_backstop_addr, sizeof(addr_t));
     } else
       s->PutCString(" unable to set a backstop breakpoint.");
   }
 }
 
 bool ThreadPlanStepThrough::ValidatePlan(Stream *error) {
   if (m_could_not_resolve_hw_bp) {
     if (error)

lldb/source/Utility/Stream.cpp

 //===-- Stream.cpp ----------------------------------------------*- C++ -*-===//
 //
 // 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 "lldb/Utility/Stream.h"
 
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/VASPrintf.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/Support/Format.h"
 #include "llvm/Support/LEB128.h"
 
 #include <string>
 
 #include <inttypes.h>
 #include <stddef.h>
 
 using namespace lldb;

 // Print a double quoted NULL terminated C string to the stream using the
 // printf format in "format".
 void Stream::QuotedCString(const char *cstr, const char *format) {
   Printf(format, cstr);
 }
 
 // Put an address "addr" out to the stream with optional prefix and suffix
 // strings.
-void Stream::Address(uint64_t addr, uint32_t addr_size, const char *prefix,
+void lldb_private::DumpAddress(llvm::raw_ostream &s, uint64_t addr,
+                               uint32_t addr_size, const char *prefix,
                                const char *suffix) {
   if (prefix == nullptr)
     prefix = "";
   if (suffix == nullptr)
     suffix = "";
-  //    int addr_width = m_addr_size << 1;
-  //    Printf ("%s0x%0*" PRIx64 "%s", prefix, addr_width, addr, suffix);
-  Printf("%s0x%0*" PRIx64 "%s", prefix, addr_size * 2, addr, suffix);
+  s << prefix << llvm::format_hex(addr, 2 + 2 * addr_size) << suffix;
 }
 
 // Put an address range out to the stream with optional prefix and suffix
 // strings.
-void Stream::AddressRange(uint64_t lo_addr, uint64_t hi_addr,
-                          uint32_t addr_size, const char *prefix,
-                          const char *suffix) {
+void lldb_private::DumpAddressRange(llvm::raw_ostream &s, uint64_t lo_addr,
+                                    uint64_t hi_addr, uint32_t addr_size,
+                                    const char *prefix, const char *suffix) {
   if (prefix && prefix[0])
-    PutCString(prefix);
-  Address(lo_addr, addr_size, "[");
-  Address(hi_addr, addr_size, "-", ")");
+    s << prefix;
+  DumpAddress(s, lo_addr, addr_size, "[");
+  DumpAddress(s, hi_addr, addr_size, "-", ")");
   if (suffix && suffix[0])
-    PutCString(suffix);
+    s << suffix;
 }
 
 size_t Stream::PutChar(char ch) { return Write(&ch, 1); }
 
 // Print some formatted output to the stream.
 size_t Stream::Printf(const char *format, ...) {
   va_list args;
   va_start(args, format);

lldb/source/Utility/VMRange.cpp

 bool VMRange::ContainsRange(const VMRange::collection &coll,
                             const VMRange &range) {
   return llvm::find_if(coll, [&](const VMRange &r) {
            return r.Contains(range);
          }) != coll.end();
 }
 
 void VMRange::Dump(Stream *s, lldb::addr_t offset, uint32_t addr_width) const {
-  s->AddressRange(offset + GetBaseAddress(), offset + GetEndAddress(),
-                  addr_width);
+  DumpAddressRange(s->AsRawOstream(), offset + GetBaseAddress(),
+                   offset + GetEndAddress(), addr_width);
 }
 
 bool lldb_private::operator==(const VMRange &lhs, const VMRange &rhs) {
   return lhs.GetBaseAddress() == rhs.GetBaseAddress() &&
          lhs.GetEndAddress() == rhs.GetEndAddress();
 }
 
 bool lldb_private::operator!=(const VMRange &lhs, const VMRange &rhs) {

lldb/unittests/Utility/StreamTest.cpp

 struct BinaryStreamTest : StreamTest {
   void SetUp() override {
     s.GetFlags().Set(Stream::eBinary);
   }
 };
 }
 
 TEST_F(StreamTest, AddressPrefix) {
-  s.Address(0x1, 1, "foo");
+  DumpAddress(s.AsRawOstream(), 0x1, 1, "foo");
   EXPECT_EQ("foo0x01", TakeValue());
 }
 
 TEST_F(StreamTest, AddressEmptyPrefix) {
-  s.Address(0x1, 1, nullptr);
+  DumpAddress(s.AsRawOstream(), 0x1, 1, nullptr);
   EXPECT_EQ("0x01", TakeValue());
-  s.Address(0x1, 1, "");
+  DumpAddress(s.AsRawOstream(), 0x1, 1, "");
   EXPECT_EQ("0x01", TakeValue());
 }
 
 TEST_F(StreamTest, AddressSuffix) {
-  s.Address(0x1, 1, nullptr, "foo");
+  DumpAddress(s.AsRawOstream(), 0x1, 1, nullptr, "foo");
   EXPECT_EQ("0x01foo", TakeValue());
 }
 
 TEST_F(StreamTest, AddressNoSuffix) {
-  s.Address(0x1, 1, nullptr, nullptr);
+  DumpAddress(s.AsRawOstream(), 0x1, 1, nullptr, nullptr);
   EXPECT_EQ("0x01", TakeValue());
-  s.Address(0x1, 1, nullptr, "");
+  DumpAddress(s.AsRawOstream(), 0x1, 1, nullptr, "");
   EXPECT_EQ("0x01", TakeValue());
 }
 
 TEST_F(StreamTest, AddressPrefixAndSuffix) {
-  s.Address(0x1, 1, "foo", "bar");
+  DumpAddress(s.AsRawOstream(), 0x1, 1, "foo", "bar");
   EXPECT_EQ("foo0x01bar", TakeValue());
 }
 
 TEST_F(StreamTest, AddressSize) {
-  s.Address(0x0, 0);
+  DumpAddress(s.AsRawOstream(), 0x0, 0);
   EXPECT_EQ("0x0", TakeValue());
-  s.Address(0x1, 0);
+  DumpAddress(s.AsRawOstream(), 0x1, 0);
   EXPECT_EQ("0x1", TakeValue());
 
-  s.Address(0x1, 1);
+  DumpAddress(s.AsRawOstream(), 0x1, 1);
   EXPECT_EQ("0x01", TakeValue());
-  s.Address(0xf1, 1);
+  DumpAddress(s.AsRawOstream(), 0xf1, 1);
   EXPECT_EQ("0xf1", TakeValue());
-  s.Address(0xff, 1);
+  DumpAddress(s.AsRawOstream(), 0xff, 1);
   EXPECT_EQ("0xff", TakeValue());
-  s.Address(0x100, 1);
+  DumpAddress(s.AsRawOstream(), 0x100, 1);
   EXPECT_EQ("0x100", TakeValue());
 
-  s.Address(0xf00, 4);
+  DumpAddress(s.AsRawOstream(), 0xf00, 4);
   EXPECT_EQ("0x00000f00", TakeValue());
-  s.Address(0x100, 8);
+  DumpAddress(s.AsRawOstream(), 0x100, 8);
   EXPECT_EQ("0x0000000000000100", TakeValue());
-  s.Address(0x100, 10);
-  EXPECT_EQ("0x00000000000000000100", TakeValue());
-  s.Address(0x1234, 10);
-  EXPECT_EQ("0x00000000000000001234", TakeValue());
 }
 
 TEST_F(StreamTest, AddressRange) {
-  s.AddressRange(0x100, 0x101, 2);
+  DumpAddressRange(s.AsRawOstream(), 0x100, 0x101, 2);
   EXPECT_EQ("[0x0100-0x0101)", TakeValue());
 }
 
 TEST_F(StreamTest, AddressRangeEmptyRange) {
-  s.AddressRange(0x100, 0x100, 2);
+  DumpAddressRange(s.AsRawOstream(), 0x100, 0x100, 2);
   EXPECT_EQ("[0x0100-0x0100)", TakeValue());
-  s.AddressRange(0x0, 0x0, 2);
+  DumpAddressRange(s.AsRawOstream(), 0x0, 0x0, 2);
   EXPECT_EQ("[0x0000-0x0000)", TakeValue());
 }
 
 TEST_F(StreamTest, AddressRangeInvalidRange) {
-  s.AddressRange(0x100, 0x0FF, 2);
+  DumpAddressRange(s.AsRawOstream(), 0x100, 0x0FF, 2);
   EXPECT_EQ("[0x0100-0x00ff)", TakeValue());
-  s.AddressRange(0x100, 0x0, 2);
+  DumpAddressRange(s.AsRawOstream(), 0x100, 0x0, 2);
   EXPECT_EQ("[0x0100-0x0000)", TakeValue());
 }
 
 TEST_F(StreamTest, AddressRangeSize) {
-  s.AddressRange(0x100, 0x101, 0);
+  DumpAddressRange(s.AsRawOstream(), 0x100, 0x101, 0);
   EXPECT_EQ("[0x100-0x101)", TakeValue());
-  s.AddressRange(0x100, 0x101, 2);
+  DumpAddressRange(s.AsRawOstream(), 0x100, 0x101, 2);
   EXPECT_EQ("[0x0100-0x0101)", TakeValue());
-  s.AddressRange(0x100, 0x101, 4);
+  DumpAddressRange(s.AsRawOstream(), 0x100, 0x101, 4);
   EXPECT_EQ("[0x00000100-0x00000101)", TakeValue());
 
-  s.AddressRange(0x100, 0x101, 4);
+  DumpAddressRange(s.AsRawOstream(), 0x100, 0x101, 4);
   EXPECT_EQ("[0x00000100-0x00000101)", TakeValue());
-  s.AddressRange(0x1, 0x101, 4);
+  DumpAddressRange(s.AsRawOstream(), 0x1, 0x101, 4);
   EXPECT_EQ("[0x00000001-0x00000101)", TakeValue());
-  s.AddressRange(0x101, 0x1, 4);
+  DumpAddressRange(s.AsRawOstream(), 0x101, 0x1, 4);
   EXPECT_EQ("[0x00000101-0x00000001)", TakeValue());
 
-  s.AddressRange(0x1, 0x101, 1);
+  DumpAddressRange(s.AsRawOstream(), 0x1, 0x101, 1);
   EXPECT_EQ("[0x01-0x101)", TakeValue());
 }
 
 TEST_F(StreamTest, ChangingByteOrder) {
   s.SetByteOrder(lldb::eByteOrderPDP);
   EXPECT_EQ(lldb::eByteOrderPDP, s.GetByteOrder());
 }