[lldb] remove unsigned Stream::operator<< overloads

[labath]

Summary

I recently re-discovered that the unsinged stream operators of the
lldb_private::Stream class have a surprising behavior in that they print
the number in hex. This is all the more confusing because the "signed"
versions of those operators behave normally.

Now that, thanks to Raphael, each Stream class has a llvm::raw_ostream
wrapper, I think we should delete most of our formatting capabilities
and just delegate to that. This patch tests the water by just deleting
the operators with the most surprising behavior.

Most of the code using these operators was printing user_id_t values. It
wasn't fully consistent about prefixing them with "0x", but I've tried
to consistenly print it without that prefix, to make it more obviously
different from pointer values.

[JDevlieghere]

🥳

lldb/include/lldb/Utility/Stream.h

public:
   /// \param[in] ch
   ///     A printable character value.
   ///
   /// \return
   ///     A reference to this class so multiple things can be streamed
   ///     in one statement.
   Stream &operator<<(char ch);
 
-  /// Output a uint8_t \a uval to the stream \a s.
-  ///
-  /// \param[in] uval
-  ///     A uint8_t value.
-  ///
-  /// \return
-  ///     A reference to this class so multiple things can be streamed
-  ///     in one statement.
-  Stream &operator<<(uint8_t uval);
-
-  /// Output a uint16_t \a uval to the stream \a s.
-  ///
-  /// \param[in] uval
-  ///     A uint16_t value.
-  ///
-  /// \return
-  ///     A reference to this class so multiple things can be streamed
-  ///     in one statement.
-  Stream &operator<<(uint16_t uval);
-
-  /// Output a uint32_t \a uval to the stream \a s.
-  ///
-  /// \param[in] uval
-  ///     A uint32_t value.
-  ///
-  /// \return
-  ///     A reference to this class so multiple things can be streamed
-  ///     in one statement.
-  Stream &operator<<(uint32_t uval);
-
-  /// Output a uint64_t \a uval to the stream \a s.
-  ///
-  /// \param[in] uval
-  ///     A uint64_t value.
-  ///
-  /// \return
-  ///     A reference to this class so multiple things can be streamed
-  ///     in one statement.
-  Stream &operator<<(uint64_t uval);
+  Stream &operator<<(uint8_t uval) = delete;
+  Stream &operator<<(uint16_t uval) = delete;
+  Stream &operator<<(uint32_t uval) = delete;
+  Stream &operator<<(uint64_t uval) = delete;
 
   /// Output a int8_t \a sval to the stream \a s.
   ///
   /// \param[in] sval
   ///     A int8_t value.
   ///
   /// \return
   ///     A reference to this class so multiple things can be streamed

lldb/source/Expression/DWARFExpression.cpp

while (m_data.ValidOffset(offset)) {
         if ((m_data.GetAddressByteSize() == 4 &&
              (begin_addr_offset == UINT32_MAX)) ||
             (m_data.GetAddressByteSize() == 8 &&
              (begin_addr_offset == UINT64_MAX))) {
           curr_base_addr = end_addr_offset + location_list_base_addr;
           // We have a new base address
           if (count > 0)
             s->PutCString(", ");
-          *s << "base_addr = " << end_addr_offset;
+          s->Format("base_addr = {0:x}", end_addr_offset);
         }
       }
 
       count++;
     }
   } else {
     // We have a normal location that contains DW_OP location opcodes
     DumpLocation(s, 0, m_data.GetByteSize(), level, abi);

lldb/source/Symbol/SymbolContext.cpp

void SymbolContext::Dump(Stream *s, Target *target) const {
   s->Indent();
   *s << "Module       = " << module_sp.get() << ' ';
   if (module_sp)
     module_sp->GetFileSpec().Dump(s);
   s->EOL();
   s->Indent();
   *s << "CompileUnit  = " << comp_unit;
   if (comp_unit != nullptr)
-    *s << " {0x" << comp_unit->GetID() << "} "
-       << *(static_cast<FileSpec *>(comp_unit));
+    s->Format(" {{{0:x-16}} {1}", comp_unit->GetID(),
+              *static_cast<FileSpec *>(comp_unit));
   s->EOL();
   s->Indent();
   *s << "Function     = " << function;
   if (function != nullptr) {
-    *s << " {0x" << function->GetID() << "} " << function->GetType()->GetName()
-       << ", address-range = ";
+    s->Format(" {{{0:x-16}} {1}, address-range = ", function->GetID(),
+              function->GetType()->GetName());
     function->GetAddressRange().Dump(s, target, Address::DumpStyleLoadAddress,
                                      Address::DumpStyleModuleWithFileAddress);
     s->EOL();
     s->Indent();
     Type *func_type = function->GetType();
     if (func_type) {
       *s << "        Type = ";
       func_type->Dump(s, false);
     }
   }
   s->EOL();
   s->Indent();
   *s << "Block        = " << block;
   if (block != nullptr)
-    *s << " {0x" << block->GetID() << '}';
-  // Dump the block and pass it a negative depth to we print all the parent
-  // blocks if (block != NULL)
-  //  block->Dump(s, function->GetFileAddress(), INT_MIN);
+    s->Format(" {{{0:x-16}}", block->GetID());
   s->EOL();
   s->Indent();
   *s << "LineEntry    = ";
   line_entry.Dump(s, target, true, Address::DumpStyleLoadAddress,
                   Address::DumpStyleModuleWithFileAddress, true);
   s->EOL();
   s->Indent();
   *s << "Symbol       = " << symbol;
   if (symbol != nullptr && symbol->GetMangled())
     *s << ' ' << symbol->GetName().AsCString();
   s->EOL();
   *s << "Variable     = " << variable;
   if (variable != nullptr) {
-    *s << " {0x" << variable->GetID() << "} " << variable->GetType()->GetName();
+    s->Format(" {{{0:x-16}} {1}", variable->GetID(),
+              variable->GetType()->GetName());
     s->EOL();
   }
   s->IndentLess();
   s->IndentLess();
 }
 
 bool lldb_private::operator==(const SymbolContext &lhs,
                               const SymbolContext &rhs) {

lldb/source/Symbol/Type.cpp

void Type::Dump(Stream *s, bool show_context) {
 
   bool show_fullpaths = false;
   m_decl.Dump(s, show_fullpaths);
 
   if (m_compiler_type.IsValid()) {
     *s << ", compiler_type = " << m_compiler_type.GetOpaqueQualType() << ' ';
     GetForwardCompilerType().DumpTypeDescription(s);
   } else if (m_encoding_uid != LLDB_INVALID_UID) {
-    *s << ", type_data = " << (uint64_t)m_encoding_uid;
+    s->Format(", type_data = {0:x-16}", m_encoding_uid);
     switch (m_encoding_uid_type) {
     case eEncodingInvalid:
       break;
     case eEncodingIsUID:
       s->PutCString(" (unresolved type)");
       break;
     case eEncodingIsConstUID:
       s->PutCString(" (unresolved const type)");

lldb/source/Symbol/Variable.cpp

void Variable::Dump(Stream *s, bool show_context) const {
   *s << "Variable" << (const UserID &)*this;
 
   if (m_name)
     *s << ", name = \"" << m_name << "\"";
 
   if (m_symfile_type_sp) {
     Type *type = m_symfile_type_sp->GetType();
     if (type) {
-      *s << ", type = {" << type->GetID() << "} " << (void *)type << " (";
+      s->Format(", type = {{{0:x-16}} {1} (", type->GetID(), type);
       type->DumpTypeName(s);
       s->PutChar(')');
     }
   }
 
   if (m_scope != eValueTypeInvalid) {
     s->PutCString(", scope = ");
     switch (m_scope) {

lldb/source/Utility/Stream.cpp

 }
 
 // Stream the pointer value out to this stream.
 Stream &Stream::operator<<(const void *p) {
   Printf("0x%.*tx", static_cast<int>(sizeof(const void *)) * 2, (ptrdiff_t)p);
   return *this;
 }
 
-// Stream a uint8_t "uval" out to this stream.
-Stream &Stream::operator<<(uint8_t uval) {
-  PutHex8(uval);
-  return *this;
-}
-
-// Stream a uint16_t "uval" out to this stream.
-Stream &Stream::operator<<(uint16_t uval) {
-  PutHex16(uval, m_byte_order);
-  return *this;
-}
-
-// Stream a uint32_t "uval" out to this stream.
-Stream &Stream::operator<<(uint32_t uval) {
-  PutHex32(uval, m_byte_order);
-  return *this;
-}
-
-// Stream a uint64_t "uval" out to this stream.
-Stream &Stream::operator<<(uint64_t uval) {
-  PutHex64(uval, m_byte_order);
-  return *this;
-}
-
 // Stream a int8_t "sval" out to this stream.
 Stream &Stream::operator<<(int8_t sval) {
   Printf("%i", static_cast<int>(sval));
   return *this;
 }
 
 // Stream a int16_t "sval" out to this stream.
 Stream &Stream::operator<<(int16_t sval) {

lldb/test/Shell/SymbolFile/DWARF/array-sizes.s

 # This tests a bug where we would incorrectly parse the size of an array if that
 # size happened to match an existing DIE offset. This happened because we
 # misinterpreted that value as a reference to a DIE specifying the VLA size even
 # though the form was a data form (as it should be).
 
 # REQUIRES: lld, x86
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: lldb-test symbols %t | FileCheck %s
 
 # CHECK: Variable{0x7fffffff0000001e}, name = "X"
-# CHECK-SAME: type = {7fffffff00000033} 0x{{[0-9a-f]*}} (char [56])
+# CHECK-SAME: type = {7fffffff00000033} 0x{{[0-9A-F]*}} (char [56])
 
 
 # Generated from "char X[47];"
 # The array size was modified by hand.
 
   .text
   .file "-"
   .file 1 "/tmp" "<stdin>"

lldb/unittests/Utility/StreamTest.cpp

TEST_F(StreamTest, ShiftOperatorInts) {
   s << std::numeric_limits<int8_t>::max() << " ";
   s << std::numeric_limits<int16_t>::max() << " ";
   s << std::numeric_limits<int32_t>::max() << " ";
   s << std::numeric_limits<int64_t>::max();
   EXPECT_EQ(40U, s.GetWrittenBytes());
   EXPECT_EQ("127 32767 2147483647 9223372036854775807", TakeValue());
 }
 
-TEST_F(StreamTest, ShiftOperatorUInts) {
-  s << std::numeric_limits<uint8_t>::max() << " ";
-  s << std::numeric_limits<uint16_t>::max() << " ";
-  s << std::numeric_limits<uint32_t>::max() << " ";
-  s << std::numeric_limits<uint64_t>::max();
-  EXPECT_EQ(33U, s.GetWrittenBytes());
-  EXPECT_EQ("ff ffff ffffffff ffffffffffffffff", TakeValue());
-}
-
 TEST_F(StreamTest, ShiftOperatorPtr) {
   // This test is a bit tricky because pretty much everything related to
   // pointer printing seems to lead to UB or IB. So let's make the most basic
   // test that just checks that we print *something*. This way we at least know
   // that pointer printing doesn't do really bad things (e.g. crashing, reading
   // OOB/uninitialized memory which the sanitizers would spot).
 
   // Shift our own pointer to the output.