Make stream::operator<< take "const" void *

[labath]

Summary

This enables us to avoid casts to "void *" in some cases and avoids a couple of "casts off const
qualifiers" warnings.

[clayborg]

Looks good.

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

public:
     /// @param[in] p
     ///     A void pointer.
     ///
     /// @return
     ///     A reference to this class so multiple things can be streamed
     ///     in one statement.
     //------------------------------------------------------------------
     Stream&
-    operator<< (void *p);
+    operator<< (const void *p);
 
     //------------------------------------------------------------------
     /// Output a character \a ch to the stream \a s.
     ///
     /// @param[in] ch
     ///     A printable character value.
     ///
     /// @return

lldb/trunk/source/Core/Stream.cpp

Stream::operator<<  (const char *s)
     Printf ("%s", s);
     return *this;
 }
 
 //------------------------------------------------------------------
 // Stream the pointer value out to this stream.
 //------------------------------------------------------------------
 Stream&
-Stream::operator<< (void *p)
+Stream::operator<< (const void *p)
 {
-    Printf ("0x%.*tx", (int)sizeof(void*) * 2, (ptrdiff_t)p);
+    Printf ("0x%.*tx", (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)

lldb/trunk/source/Symbol/SymbolContext.cpp

SymbolContext::GetResolvedMask () const
     if (symbol)                 resolved_mask |= eSymbolContextSymbol;
     if (variable)               resolved_mask |= eSymbolContextVariable;
     return resolved_mask;
 }
 
 void
 SymbolContext::Dump(Stream *s, Target *target) const
 {
-    *s << (void *)this << ": ";
+    *s << this << ": ";
     s->Indent();
     s->PutCString("SymbolContext");
     s->IndentMore();
     s->EOL();
     s->IndentMore();
     s->Indent();
-    *s << "Module       = " << (void *)module_sp.get() << ' ';
+    *s << "Module       = " << module_sp.get() << ' ';
     if (module_sp)
         module_sp->GetFileSpec().Dump(s);
     s->EOL();
     s->Indent();
-    *s << "CompileUnit  = " << (void *)comp_unit;
+    *s << "CompileUnit  = " << comp_unit;
     if (comp_unit != nullptr)
         *s << " {0x" << comp_unit->GetID() << "} " << *(static_cast<FileSpec*> (comp_unit));
     s->EOL();
     s->Indent();
-    *s << "Function     = " << (void *)function;
+    *s << "Function     = " << function;
     if (function != nullptr)
     {
         *s << " {0x" << function->GetID() << "} " << function->GetType()->GetName() << ", address-range = ";
         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        = " << (void *)block;
+    *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->EOL();
     s->Indent();
     *s << "LineEntry    = ";
     line_entry.Dump (s, target, true, Address::DumpStyleLoadAddress, Address::DumpStyleModuleWithFileAddress, true);
     s->EOL();
     s->Indent();
-    *s << "Symbol       = " << (void *)symbol;
+    *s << "Symbol       = " << symbol;
     if (symbol != nullptr && symbol->GetMangled())
         *s << ' ' << symbol->GetName().AsCString();
     s->EOL();
-    *s << "Variable     = " << (void *)variable;
+    *s << "Variable     = " << variable;
     if (variable != nullptr)
     {
         *s << " {0x" << variable->GetID() << "} " << variable->GetType()->GetName();
         s->EOL();
     }
     s->IndentLess();
     s->IndentLess();
 }

 {
     m_symbol_contexts.clear();
 }
 
 void
 SymbolContextList::Dump(Stream *s, Target *target) const
 {
 
-    *s << (void *)this << ": ";
+    *s << this << ": ";
     s->Indent();
     s->PutCString("SymbolContextList");
     s->EOL();
     s->IndentMore();
 
     collection::const_iterator pos, end = m_symbol_contexts.end();
     for (pos = m_symbol_contexts.begin(); pos != end; ++pos)
     {