Remove a couple of Stream flags

[labath]

Summary

I came across this while trying to understand what Log::Debug does. It turns out
it does not do anything, as there is no instance of someone setting a debug flag
on a stream. The same is true for the Verbose and AddPrefix flags. Removing
these will enable some cleanups in the Logging class, and it brings us closer
towards the long term goal of standardizing on llvm stream classes.

I have removed these flags and all code the code which tested for their
presence -- there wasn't much of it, mostly in SymbolFileDWARF, which is
probably going away at some point anyway.

The eBinary flag still has some users, so I am letting it life for the time
being.

[clayborg]

Most of the DWARF stuff is about to go away anyway in favor of using the LLVM DWARF parser as I am currently modifying it to support all we need in LLDB so we can get rid of the entire DWARF parsers, so many of these changes are fine.

Just fix the definition of eBinary to be (1<<0) and this is good to go.

include/lldb/Core/Stream.h

36 ↗

(On Diff #84143)

No one serializes this flag or sets it manually, so make it equal to (1<<0).

[jingham]

Is this going to make passing LIBLLDB_LOG_OPTION_VERBOSE to GetLogIfAllCategoriesSet into a "you can't see these logs" operation?

I use this in a couple places where I have detailed information that I usually don't want to see, but in some odd cases I might need it. Loosing this capability would be a shame.

[labath]

In D28616#644287, @jingham wrote:

Is this going to make passing LIBLLDB_LOG_OPTION_VERBOSE to GetLogIfAllCategoriesSet into a "you can't see these logs" operation?

I use this in a couple places where I have detailed information that I usually don't want to see, but in some odd cases I might need it. Loosing this capability would be a shame.

That is not going to be affected - I am not touching that flag. I am removing a *separate* flag on the Stream level, which was never set (although some of the (effectively dead) code did test for it's existence). See old and new implementations of Log::GetVerbose to see what I mean.

[jingham]

Yeah, I'm starting to remember this a bit. For some reason, we have individual log channels with verbose as a category (LIBLLDB_LOG_VERBOSE, POSIX_LOG_VERBOSE, KDP_LOG_VERBOSE) and we have LLDB_LOG_OPTION_VERBOSE which is set "GetVerbose" is testing for.

So you can do:

log enable -v lldb memory

or

log enable lldb memory verbose

and they will do different things depending on who checks what. That seems really confusing. We should remove the verbose category and have everybody check GetVerbose instead. But that's orthogonal to this patch.

lldb/trunk/include/lldb/Core/Stream.h

 /// @brief A stream class that can stream formatted output to a file.
 //----------------------------------------------------------------------
 class Stream {
 public:
   //------------------------------------------------------------------
   /// \a m_flags bit values.
   //------------------------------------------------------------------
   enum {
-    eVerbose = (1 << 0),   ///< If set, verbose logging is enabled
-    eDebug = (1 << 1),     ///< If set, debug logging is enabled
-    eAddPrefix = (1 << 2), ///< Add number prefixes for binary, octal and hex
-                           ///when eBinary is clear
-    eBinary = (1 << 3) ///< Get and put data as binary instead of as the default
+    eBinary = (1 << 0) ///< Get and put data as binary instead of as the default
                        ///string mode.
   };
 
   //------------------------------------------------------------------
   /// Construct with flags and address size and byte order.
   ///
   /// Construct with dump flags \a flags and the default address
   /// size. \a flags can be any of the above enumeration logical OR'ed
public:
   ///
   /// @return
   ///     The size of an address in bytes that is used when outputting
   ///     address and pointer values to the stream.
   //------------------------------------------------------------------
   uint32_t GetAddressByteSize() const;
 
   //------------------------------------------------------------------
-  /// Test if debug logging is enabled.
-  ///
-  /// @return
-  //      \b true if the debug flag bit is set in this stream, \b
-  //      false otherwise.
-  //------------------------------------------------------------------
-  bool GetDebug() const;
-
-  //------------------------------------------------------------------
   /// The flags accessor.
   ///
   /// @return
   ///     A reference to the Flags member variable.
   //------------------------------------------------------------------
   Flags &GetFlags();
 
   //------------------------------------------------------------------
public:
   /// Get the current indentation level.
   ///
   /// @return
   ///     The current indentation level as an integer.
   //------------------------------------------------------------------
   int GetIndentLevel() const;
 
   //------------------------------------------------------------------
-  /// Test if verbose logging is enabled.
-  ///
-  /// @return
-  //      \b true if the verbose flag bit is set in this stream, \b
-  //      false otherwise.
-  //------------------------------------------------------------------
-  bool GetVerbose() const;
-
-  //------------------------------------------------------------------
   /// Indent the current line in the stream.
   ///
   /// Indent the current line using the current indentation level and
   /// print an optional string following the indentation spaces.
   ///
   /// @param[in] s
   ///     A C string to print following the indentation. If nullptr, just
   ///     output the indentation characters.

lldb/trunk/source/Core/Log.cpp

for (idx = 0;
        (name = PluginManager::GetLogChannelCreateNameAtIndex(idx)) != nullptr;
        ++idx) {
     LogChannelSP log_channel_sp(LogChannel::FindPlugin(name));
     if (log_channel_sp)
       log_channel_sp->ListCategories(strm);
   }
 }
 
-bool Log::GetVerbose() const {
-  // FIXME: This has to be centralized between the stream and the log...
-  if (m_options.Test(LLDB_LOG_OPTION_VERBOSE))
-    return true;
-
-  // Make a copy of our stream shared pointer in case someone disables our
-  // log while we are logging and releases the stream
-  StreamSP stream_sp(m_stream_sp);
-  if (stream_sp)
-    return stream_sp->GetVerbose();
-  return false;
-}
+bool Log::GetVerbose() const { return m_options.Test(LLDB_LOG_OPTION_VERBOSE); }
 
 //------------------------------------------------------------------
 // Returns true if the debug flag bit is set in this stream.
 //------------------------------------------------------------------
 bool Log::GetDebug() const {
-  // Make a copy of our stream shared pointer in case someone disables our
-  // log while we are logging and releases the stream
-  StreamSP stream_sp(m_stream_sp);
-  if (stream_sp)
-    return stream_sp->GetDebug();
+  // TODO: remove and clean up callers
   return false;
 }
 
 LogChannelSP LogChannel::FindPlugin(const char *plugin_name) {
   LogChannelSP log_channel_sp;
   LogChannelMap &channel_map = GetChannelMap();
   ConstString log_channel_name(plugin_name);
   LogChannelMapIter pos = channel_map.find(log_channel_name);

lldb/trunk/source/Core/SearchFilter.cpp

if (FileSpec::Equal(m_module_spec, module->GetFileSpec(), full_match)) {
       if (shouldContinue == Searcher::eCallbackReturnStop)
         return;
     }
   }
 }
 
 void SearchFilterByModule::GetDescription(Stream *s) {
   s->PutCString(", module = ");
-  if (s->GetVerbose()) {
-    char buffer[2048];
-    m_module_spec.GetPath(buffer, 2047);
-    s->PutCString(buffer);
-  } else {
-    s->PutCString(m_module_spec.GetFilename().AsCString("<Unknown>"));
-  }
-}
 
 uint32_t SearchFilterByModule::GetFilterRequiredItems() {
   return eSymbolContextModule;
 }
 
 void SearchFilterByModule::Dump(Stream *s) const {}
 
 lldb::SearchFilterSP
for (size_t i = 0; i < num_modules; i++) {
     }
   }
 }
 
 void SearchFilterByModuleList::GetDescription(Stream *s) {
   size_t num_modules = m_module_spec_list.GetSize();
   if (num_modules == 1) {
     s->Printf(", module = ");
-    if (s->GetVerbose()) {
-      char buffer[2048];
-      m_module_spec_list.GetFileSpecAtIndex(0).GetPath(buffer, 2047);
-      s->PutCString(buffer);
-    } else {
-      s->PutCString(
-          m_module_spec_list.GetFileSpecAtIndex(0).GetFilename().AsCString(
-              "<Unknown>"));
-    }
   } else {
     s->Printf(", modules(%" PRIu64 ") = ", (uint64_t)num_modules);
     for (size_t i = 0; i < num_modules; i++) {
-      if (s->GetVerbose()) {
-        char buffer[2048];
-        m_module_spec_list.GetFileSpecAtIndex(i).GetPath(buffer, 2047);
-        s->PutCString(buffer);
-      } else {
-        s->PutCString(
-            m_module_spec_list.GetFileSpecAtIndex(i).GetFilename().AsCString(
-                "<Unknown>"));
-      }
       if (i != num_modules - 1)
         s->PutCString(", ");
     }
   }
 }
 
 uint32_t SearchFilterByModuleList::GetFilterRequiredItems() {
   return eSymbolContextModule;
for (size_t i = 0; i < num_modules; i++) {
     }
   }
 }
 
 void SearchFilterByModuleListAndCU::GetDescription(Stream *s) {
   size_t num_modules = m_module_spec_list.GetSize();
   if (num_modules == 1) {
     s->Printf(", module = ");
-    if (s->GetVerbose()) {
-      char buffer[2048];
-      m_module_spec_list.GetFileSpecAtIndex(0).GetPath(buffer, 2047);
-      s->PutCString(buffer);
-    } else {
-      s->PutCString(
-          m_module_spec_list.GetFileSpecAtIndex(0).GetFilename().AsCString(
-              "<Unknown>"));
-    }
   } else if (num_modules > 0) {
     s->Printf(", modules(%" PRIu64 ") = ", static_cast<uint64_t>(num_modules));
     for (size_t i = 0; i < num_modules; i++) {
-      if (s->GetVerbose()) {
-        char buffer[2048];
-        m_module_spec_list.GetFileSpecAtIndex(i).GetPath(buffer, 2047);
-        s->PutCString(buffer);
-      } else {
-        s->PutCString(
-            m_module_spec_list.GetFileSpecAtIndex(i).GetFilename().AsCString(
-                "<Unknown>"));
-      }
       if (i != num_modules - 1)
         s->PutCString(", ");
     }
   }
 }
 
 uint32_t SearchFilterByModuleListAndCU::GetFilterRequiredItems() {
   return eSymbolContextModule | eSymbolContextCompUnit;

lldb/trunk/source/Core/Stream.cpp

 uint32_t Stream::GetAddressByteSize() const { return m_addr_size; }
 
 //------------------------------------------------------------------
 // Set the address size in bytes
 //------------------------------------------------------------------
 void Stream::SetAddressByteSize(uint32_t addr_size) { m_addr_size = addr_size; }
 
 //------------------------------------------------------------------
-// Returns true if the verbose flag bit is set in this stream.
-//------------------------------------------------------------------
-bool Stream::GetVerbose() const { return m_flags.Test(eVerbose); }
-
-//------------------------------------------------------------------
-// Returns true if the debug flag bit is set in this stream.
-//------------------------------------------------------------------
-bool Stream::GetDebug() const { return m_flags.Test(eDebug); }
-
-//------------------------------------------------------------------
 // The flags get accessor
 //------------------------------------------------------------------
 Flags &Stream::GetFlags() { return m_flags; }
 
 //------------------------------------------------------------------
 // The flags const get accessor
 //------------------------------------------------------------------
 const Flags &Stream::GetFlags() const { return m_flags; }
size_t Stream::PrintfAsRawHex8(const char *format, ...) {
   va_end(args_copy);
 
   return bytes_written;
 }
 
 size_t Stream::PutNHex8(size_t n, uint8_t uvalue) {
   size_t bytes_written = 0;
   for (size_t i = 0; i < n; ++i)
-    bytes_written += _PutHex8(uvalue, m_flags.Test(eAddPrefix));
+    bytes_written += _PutHex8(uvalue, false);
   return bytes_written;
 }
 
 size_t Stream::_PutHex8(uint8_t uvalue, bool add_prefix) {
   size_t bytes_written = 0;
   if (m_flags.Test(eBinary)) {
     bytes_written = Write(&uvalue, 1);
   } else {
     if (add_prefix)
       PutCString("0x");
 
     static char g_hex_to_ascii_hex_char[16] = {'0', '1', '2', '3', '4', '5',
                                                '6', '7', '8', '9', 'a', 'b',
                                                'c', 'd', 'e', 'f'};
     char nibble_chars[2];
     nibble_chars[0] = g_hex_to_ascii_hex_char[(uvalue >> 4) & 0xf];
     nibble_chars[1] = g_hex_to_ascii_hex_char[(uvalue >> 0) & 0xf];
     bytes_written = Write(nibble_chars, sizeof(nibble_chars));
   }
   return bytes_written;
 }
 
-size_t Stream::PutHex8(uint8_t uvalue) {
-  return _PutHex8(uvalue, m_flags.Test(eAddPrefix));
-}
+size_t Stream::PutHex8(uint8_t uvalue) { return _PutHex8(uvalue, false); }
 
 size_t Stream::PutHex16(uint16_t uvalue, ByteOrder byte_order) {
   if (byte_order == eByteOrderInvalid)
     byte_order = m_byte_order;
 
-  bool add_prefix = m_flags.Test(eAddPrefix);
   size_t bytes_written = 0;
   if (byte_order == eByteOrderLittle) {
-    for (size_t byte = 0; byte < sizeof(uvalue); ++byte, add_prefix = false)
-      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), add_prefix);
+    for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
+      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
   } else {
-    for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue);
-         --byte, add_prefix = false)
-      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), add_prefix);
+    for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
+      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
   }
   return bytes_written;
 }
 
 size_t Stream::PutHex32(uint32_t uvalue, ByteOrder byte_order) {
   if (byte_order == eByteOrderInvalid)
     byte_order = m_byte_order;
 
-  bool add_prefix = m_flags.Test(eAddPrefix);
   size_t bytes_written = 0;
   if (byte_order == eByteOrderLittle) {
-    for (size_t byte = 0; byte < sizeof(uvalue); ++byte, add_prefix = false)
-      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), add_prefix);
+    for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
+      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
   } else {
-    for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue);
-         --byte, add_prefix = false)
-      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), add_prefix);
+    for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
+      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
   }
   return bytes_written;
 }
 
 size_t Stream::PutHex64(uint64_t uvalue, ByteOrder byte_order) {
   if (byte_order == eByteOrderInvalid)
     byte_order = m_byte_order;
 
-  bool add_prefix = m_flags.Test(eAddPrefix);
   size_t bytes_written = 0;
   if (byte_order == eByteOrderLittle) {
-    for (size_t byte = 0; byte < sizeof(uvalue); ++byte, add_prefix = false)
-      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), add_prefix);
+    for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
+      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
   } else {
-    for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue);
-         --byte, add_prefix = false)
-      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), add_prefix);
+    for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
+      bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
   }
   return bytes_written;
 }
 
 size_t Stream::PutMaxHex64(uint64_t uvalue, size_t byte_size,
                            lldb::ByteOrder byte_order) {
   switch (byte_size) {
   case 1:

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

 bool DWARFCompileUnit::Verify(Stream *s) const {
   const DWARFDataExtractor &debug_info = m_dwarf2Data->get_debug_info_data();
   bool valid_offset = debug_info.ValidOffset(m_offset);
   bool length_OK = debug_info.ValidOffset(GetNextCompileUnitOffset() - 1);
   bool version_OK = SymbolFileDWARF::SupportedVersion(m_version);
   bool abbr_offset_OK =
       m_dwarf2Data->get_debug_abbrev_data().ValidOffset(GetAbbrevOffset());
   bool addr_size_OK = ((m_addr_size == 4) || (m_addr_size == 8));
-  bool verbose = s->GetVerbose();
   if (valid_offset && length_OK && version_OK && addr_size_OK &&
       abbr_offset_OK) {
-    if (verbose)
-      s->Printf("    0x%8.8x: OK\n", m_offset);
     return true;
   } else {
     s->Printf("    0x%8.8x: ", m_offset);
 
     m_dwarf2Data->get_debug_info_data().Dump(s, m_offset, lldb::eFormatHex, 1,
                                              Size(), 32, LLDB_INVALID_ADDRESS,
                                              0, 0);
     s->EOL();

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

if (dumpInfo->die_offset == DW_INVALID_OFFSET) {
       if (cu && dumpInfo->die_offset < cu->GetFirstDIEOffset()) {
         // Not found, maybe the DIE offset provided wasn't correct?
         //  *ostrm_ptr << "DIE at offset " << HEX32 << dumpInfo->die_offset << "
         //  was not found." << endl;
         return DW_INVALID_OFFSET;
       } else {
         // See if the DIE is in this compile unit?
         if (cu && dumpInfo->die_offset < cu->GetNextCompileUnitOffset()) {
-          // This DIE is in this compile unit!
-          if (s->GetVerbose())
-            cu->Dump(s); // Dump the compile unit for the DIE in verbose mode
-
           return next_offset;
           //  // We found our compile unit that contains our DIE, just skip to
           //  dumping the requested DIE...
           //  return dumpInfo->die_offset;
         } else {
           // Skip to the next compile unit as the DIE isn't in the current one!
           if (cu) {
             return cu->GetNextCompileUnitOffset();

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

 // Dumps a debug information entry attribute along with it's form. Any
 // special display of attributes is done (disassemble location lists,
 // show enumeration values for attributes, etc).
 //----------------------------------------------------------------------
 void DWARFDebugInfoEntry::DumpAttribute(
     SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
     const DWARFDataExtractor &debug_info_data, lldb::offset_t *offset_ptr,
     Stream &s, dw_attr_t attr, dw_form_t form) {
-  bool verbose = s.GetVerbose();
   bool show_form = s.GetFlags().Test(DWARFDebugInfo::eDumpFlag_ShowForm);
 
-  if (verbose)
-    s.Offset(*offset_ptr);
-  else
-    s.Printf("            ");
   s.Indent(DW_AT_value_to_name(attr));
 
   if (show_form) {
     s.Printf("[%s", DW_FORM_value_to_name(form));
   }
 
   DWARFFormValue form_value(cu, form);
 
   if (!form_value.ExtractValue(debug_info_data, offset_ptr))
     return;
 
   if (show_form) {
     if (form == DW_FORM_indirect) {
       s.Printf(" [%s]", DW_FORM_value_to_name(form_value.Form()));
     }
 
     s.PutCString("] ");
   }
 
   s.PutCString("( ");
 
-  // Always dump form value if verbose is enabled
-  if (verbose) {
-    form_value.Dump(s);
-  }
-
   // Check to see if we have any special attribute formatters
   switch (attr) {
   case DW_AT_stmt_list:
-    if (verbose)
-      s.PutCString(" ( ");
     s.Printf("0x%8.8" PRIx64, form_value.Unsigned());
-    if (verbose)
-      s.PutCString(" )");
     break;
 
   case DW_AT_language:
-    if (verbose)
-      s.PutCString(" ( ");
     s.PutCString(DW_LANG_value_to_name(form_value.Unsigned()));
-    if (verbose)
-      s.PutCString(" )");
     break;
 
   case DW_AT_encoding:
-    if (verbose)
-      s.PutCString(" ( ");
     s.PutCString(DW_ATE_value_to_name(form_value.Unsigned()));
-    if (verbose)
-      s.PutCString(" )");
     break;
 
   case DW_AT_frame_base:
   case DW_AT_location:
   case DW_AT_data_member_location: {
     const uint8_t *blockData = form_value.BlockData();
     if (blockData) {
-      if (!verbose)
-        form_value.Dump(s);
-
       // Location description is inlined in data in the form value
       DWARFDataExtractor locationData(debug_info_data,
                                       (*offset_ptr) - form_value.Unsigned(),
                                       form_value.Unsigned());
-      if (verbose)
-        s.PutCString(" ( ");
       DWARFExpression::PrintDWARFExpression(
           s, locationData, DWARFCompileUnit::GetAddressByteSize(cu), 4, false);
-      if (verbose)
-        s.PutCString(" )");
     } else {
       // We have a location list offset as the value that is
       // the offset into the .debug_loc section that describes
       // the value over it's lifetime
       uint64_t debug_loc_offset = form_value.Unsigned();
       if (dwarf2Data) {
-        if (!verbose)
-          form_value.Dump(s);
         DWARFExpression::PrintDWARFLocationList(
             s, cu, dwarf2Data->get_debug_loc_data(), debug_loc_offset);
-      } else {
-        if (!verbose)
-          form_value.Dump(s);
       }
     }
   } break;
 
   case DW_AT_abstract_origin:
   case DW_AT_specification: {
     uint64_t abstract_die_offset = form_value.Reference();
     form_value.Dump(s);
     //  *ostrm_ptr << HEX32 << abstract_die_offset << " ( ";
-    if (verbose)
-      s.PutCString(" ( ");
     GetName(dwarf2Data, cu, abstract_die_offset, s);
-    if (verbose)
-      s.PutCString(" )");
   } break;
 
   case DW_AT_type: {
     uint64_t type_die_offset = form_value.Reference();
-    if (!verbose)
-      form_value.Dump(s);
     s.PutCString(" ( ");
     AppendTypeName(dwarf2Data, cu, type_die_offset, s);
     s.PutCString(" )");
   } break;
 
   case DW_AT_ranges: {
-    if (!verbose)
-      form_value.Dump(s);
     lldb::offset_t ranges_offset = form_value.Unsigned();
     dw_addr_t base_addr = cu ? cu->GetBaseAddress() : 0;
     if (dwarf2Data)
       DWARFDebugRanges::Dump(s, dwarf2Data->get_debug_ranges_data(),
                              &ranges_offset, base_addr);
   } break;
 
   default:
-    if (!verbose)
-      form_value.Dump(s);
     break;
   }
 
   s.PutCString(" )\n");
 }
 
 //----------------------------------------------------------------------
 // Get all attribute values for a given DIE, including following any

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

bool DWARFDebugRanges::Extract(SymbolFileDWARF *dwarf2Data,
   return range_offset != *offset_ptr;
 }
 
 void DWARFDebugRanges::Dump(Stream &s,
                             const DWARFDataExtractor &debug_ranges_data,
                             lldb::offset_t *offset_ptr,
                             dw_addr_t cu_base_addr) {
   uint32_t addr_size = s.GetAddressByteSize();
-  bool verbose = s.GetVerbose();
 
   dw_addr_t base_addr = cu_base_addr;
   while (
       debug_ranges_data.ValidOffsetForDataOfSize(*offset_ptr, 2 * addr_size)) {
     dw_addr_t begin = debug_ranges_data.GetMaxU64(offset_ptr, addr_size);
     dw_addr_t end = debug_ranges_data.GetMaxU64(offset_ptr, addr_size);
     // Extend 4 byte addresses that consists of 32 bits of 1's to be 64 bits
     // of ones
     if (begin == 0xFFFFFFFFull && addr_size == 4)
       begin = LLDB_INVALID_ADDRESS;
 
     s.Indent();
-    if (verbose) {
-      s.AddressRange(begin, end, sizeof(dw_addr_t), " offsets = ");
-    }
-
     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 = ");
     } 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),
-                     verbose ? " ==> addrs = " : NULL);
+      s.AddressRange(begin_addr, end_addr, sizeof(dw_addr_t), NULL);
     }
   }
 }
 
 bool DWARFDebugRanges::FindRanges(dw_addr_t debug_ranges_base,
                                   dw_offset_t debug_ranges_offset,
                                   DWARFRangeList &range_list) const {
   dw_addr_t debug_ranges_address = debug_ranges_base + debug_ranges_offset;
   range_map_const_iterator pos = m_range_map.find(debug_ranges_address);
   if (pos != m_range_map.end()) {
     range_list = pos->second;
     return true;
   }
   return false;
 }

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

bool DWARFFormValue::SkipValue(dw_form_t form,
   }
   return false;
 }
 
 void DWARFFormValue::Dump(Stream &s) const {
   uint64_t uvalue = Unsigned();
   bool cu_relative_offset = false;
 
-  bool verbose = s.GetVerbose();
-
   switch (m_form) {
   case DW_FORM_addr:
     s.Address(uvalue, sizeof(uint64_t));
     break;
   case DW_FORM_flag:
   case DW_FORM_data1:
     s.PutHex8(uvalue);
     break;
case DW_FORM_sdata:
     s.PutSLEB128(uvalue);
     break;
   case DW_FORM_udata:
     s.PutULEB128(uvalue);
     break;
   case DW_FORM_strp: {
     const char *dbg_str = AsCString();
     if (dbg_str) {
-      if (verbose)
-        s.Printf(" .debug_str[0x%8.8x] = ", (uint32_t)uvalue);
       s.QuotedCString(dbg_str);
     } else {
       s.PutHex32(uvalue);
     }
   } break;
 
   case DW_FORM_ref_addr: {
     assert(m_cu); // CU must be valid for DW_FORM_ref_addr objects or we will
                   // get this wrong
     if (m_cu->GetVersion() <= 2)
       s.Address(uvalue, sizeof(uint64_t) * 2);
     else
       s.Address(uvalue, 4 * 2); // 4 for DWARF32, 8 for DWARF64, but we don't
                                 // support DWARF64 yet
     break;
   }
   case DW_FORM_ref1:
     cu_relative_offset = true;
-    if (verbose)
-      s.Printf("cu + 0x%2.2x", (uint8_t)uvalue);
     break;
   case DW_FORM_ref2:
     cu_relative_offset = true;
-    if (verbose)
-      s.Printf("cu + 0x%4.4x", (uint16_t)uvalue);
     break;
   case DW_FORM_ref4:
     cu_relative_offset = true;
-    if (verbose)
-      s.Printf("cu + 0x%4.4x", (uint32_t)uvalue);
     break;
   case DW_FORM_ref8:
     cu_relative_offset = true;
-    if (verbose)
-      s.Printf("cu + 0x%8.8" PRIx64, uvalue);
     break;
   case DW_FORM_ref_udata:
     cu_relative_offset = true;
-    if (verbose)
-      s.Printf("cu + 0x%" PRIx64, uvalue);
     break;
 
   // All DW_FORM_indirect attributes should be resolved prior to calling this
   // function
   case DW_FORM_indirect:
     s.PutCString("DW_FORM_indirect");
     break;
   case DW_FORM_flag_present:
     break;
   default:
     s.Printf("DW_FORM(0x%4.4x)", m_form);
     break;
   }
 
   if (cu_relative_offset) {
     assert(m_cu); // CU must be valid for DW_FORM_ref forms that are compile
                   // unit relative or we will get this wrong
-    if (verbose)
-      s.PutCString(" => ");
-
     s.Printf("{0x%8.8" PRIx64 "}", uvalue + m_cu->GetOffset());
   }
 }
 
 const char *DWARFFormValue::AsCString() const {
   SymbolFileDWARF *symbol_file = m_cu->GetSymbolFileDWARF();
 
   if (m_form == DW_FORM_string) {

lldb/trunk/source/Symbol/Declaration.cpp

#ifdef LLDB_ENABLE_DECLARATION_COLUMNS
     else if (m_column > 0)
       s->Printf(", column = %u", m_column);
 #endif
   }
 }
 
 bool Declaration::DumpStopContext(Stream *s, bool show_fullpaths) const {
   if (m_file) {
-    if (show_fullpaths || s->GetVerbose())
+    if (show_fullpaths)
       *s << m_file;
     else
       m_file.GetFilename().Dump(s);
 
     if (m_line > 0)
       s->Printf(":%u", m_line);
 #ifdef LLDB_ENABLE_DECLARATION_COLUMNS
     if (m_column > 0)