Added copy constructors and assignment operators to all lldb::SB* classes

so we don't end up with weak exports with some compilers.

llvm-svn: 118312

lldb/source/API/SBBlock.cpp

@@ -28,6 +28,18 @@ SBBlock::SBBlock (lldb_private::Block *lldb_object_ptr) :
 {
 }
 
+SBBlock::SBBlock(const SBBlock &rhs) :
+    m_opaque_ptr (rhs.m_opaque_ptr)
+{
+}
+
+const SBBlock &
+SBBlock::operator = (const SBBlock &rhs)
+{
+    m_opaque_ptr = rhs.m_opaque_ptr;
+    return *this;
+}
+
 SBBlock::~SBBlock ()
 {
     m_opaque_ptr = NULL;

lldb/source/API/SBBreakpointLocation.cpp

@@ -25,7 +25,8 @@ using namespace lldb;
 using namespace lldb_private;
 
 
-SBBreakpointLocation::SBBreakpointLocation ()
+SBBreakpointLocation::SBBreakpointLocation () :
+    m_opaque_sp ()
 {
 }
 
@@ -43,6 +44,20 @@ SBBreakpointLocation::SBBreakpointLocation (const lldb::BreakpointLocationSP &br
     }
 }
 
+SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs) :
+    m_opaque_sp (rhs.m_opaque_sp)
+{
+}
+
+const SBBreakpointLocation &
+SBBreakpointLocation::operator = (const SBBreakpointLocation &rhs)
+{
+    if (this != &rhs)
+        m_opaque_sp = rhs.m_opaque_sp;
+    return *this;
+}
+
+
 SBBreakpointLocation::~SBBreakpointLocation ()
 {
 }

lldb/source/API/SBBroadcaster.cpp

@@ -20,36 +20,49 @@ using namespace lldb_private;
 
 
 SBBroadcaster::SBBroadcaster () :
-    m_opaque (NULL),
-    m_opaque_owned (false)
+    m_opaque_sp (),
+    m_opaque_ptr (NULL)
 {
-    Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API | LIBLLDB_LOG_VERBOSE);
-
-    if (log)
-        log->Printf ("SBBroadcastetr::SBBroadcaster () => SBBroadcaster(%p)", this);
 }
 
-
 SBBroadcaster::SBBroadcaster (const char *name) :
-    m_opaque (new Broadcaster (name)),
-    m_opaque_owned (true)
+    m_opaque_sp (new Broadcaster (name)),
+    m_opaque_ptr (NULL)
 {
+    m_opaque_ptr = m_opaque_sp.get();
     Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API | LIBLLDB_LOG_VERBOSE);
 
     if (log)
         log->Printf ("SBBroadcaster::SBBroadcaster (name=\"%s\") => SBBroadcaster(%p)",
-                     name, m_opaque);
+                     name, m_opaque_ptr);
 }
 
 SBBroadcaster::SBBroadcaster (lldb_private::Broadcaster *broadcaster, bool owns) :
-    m_opaque (broadcaster),
-    m_opaque_owned (owns)
+    m_opaque_sp (owns ? broadcaster : NULL),
+    m_opaque_ptr (broadcaster)
 {
     Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API | LIBLLDB_LOG_VERBOSE);
 
     if (log)
-        log->Printf ("SBBroadcaster::SBBroadcaster (broadcaster=%p, bool owns=%i) "
-                     " => SBBroadcaster(%p)", broadcaster, owns, m_opaque);
+        log->Printf ("SBBroadcaster::SBBroadcaster (broadcaster=%p, bool owns=%i) => SBBroadcaster(%p)", 
+                     broadcaster, owns, m_opaque_ptr);
+}
+
+SBBroadcaster::SBBroadcaster (const SBBroadcaster &rhs) :
+    m_opaque_sp (rhs.m_opaque_sp),
+    m_opaque_ptr (rhs.m_opaque_ptr) 
+{
+}
+
+const SBBroadcaster &
+SBBroadcaster::operator = (const SBBroadcaster &rhs)
+{
+    if (this != &rhs)
+    {
+        m_opaque_sp = rhs.m_opaque_sp;
+        m_opaque_ptr = rhs.m_opaque_ptr;
+    }
+    return *this;
 }
 
 SBBroadcaster::~SBBroadcaster()
@@ -63,15 +76,15 @@ SBBroadcaster::BroadcastEventByType (uint32_t event_type, bool unique)
     Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
 
     if (log)
-        log->Printf ("SBBroadcaster(%p)::BroadcastEventByType (event_type=0x%8.8x, unique=%i)", m_opaque, event_type, unique);
+        log->Printf ("SBBroadcaster(%p)::BroadcastEventByType (event_type=0x%8.8x, unique=%i)", m_opaque_ptr, event_type, unique);
 
-    if (m_opaque == NULL)
+    if (m_opaque_ptr == NULL)
         return;
 
     if (unique)
-        m_opaque->BroadcastEventIfUnique (event_type);
+        m_opaque_ptr->BroadcastEventIfUnique (event_type);
     else
-        m_opaque->BroadcastEvent (event_type);
+        m_opaque_ptr->BroadcastEvent (event_type);
 }
 
 void
@@ -80,16 +93,16 @@ SBBroadcaster::BroadcastEvent (const SBEvent &event, bool unique)
     Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
 
     if (log)
-        log->Printf ("SBBroadcaster(%p)::BroadcastEventByType (SBEvent(%p), unique=%i)", m_opaque, event.get(), unique);
+        log->Printf ("SBBroadcaster(%p)::BroadcastEventByType (SBEvent(%p), unique=%i)", m_opaque_ptr, event.get(), unique);
 
-    if (m_opaque == NULL)
+    if (m_opaque_ptr == NULL)
         return;
 
     EventSP event_sp = event.GetSP ();
     if (unique)
-        m_opaque->BroadcastEventIfUnique (event_sp);
+        m_opaque_ptr->BroadcastEventIfUnique (event_sp);
     else
-        m_opaque->BroadcastEvent (event_sp);
+        m_opaque_ptr->BroadcastEvent (event_sp);
 }
 
 void
@@ -97,74 +110,75 @@ SBBroadcaster::AddInitialEventsToListener (const SBListener &listener, uint32_t
 {
     Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
     if (log)
-        log->Printf ("SBBroadcaster(%p)::AddInitialEventsToListener (SBListener(%p), event_mask=0x%8.8x)", m_opaque, listener.get(), requested_events);
-    if (m_opaque)
-        m_opaque->AddInitialEventsToListener (listener.get(), requested_events);
+        log->Printf ("SBBroadcaster(%p)::AddInitialEventsToListener (SBListener(%p), event_mask=0x%8.8x)", m_opaque_ptr, listener.get(), requested_events);
+    if (m_opaque_ptr)
+        m_opaque_ptr->AddInitialEventsToListener (listener.get(), requested_events);
 }
 
 uint32_t
 SBBroadcaster::AddListener (const SBListener &listener, uint32_t event_mask)
 {
-    if (m_opaque)
-        return m_opaque->AddListener (listener.get(), event_mask);
+    if (m_opaque_ptr)
+        return m_opaque_ptr->AddListener (listener.get(), event_mask);
     return 0;
 }
 
 const char *
 SBBroadcaster::GetName () const
 {
-    if (m_opaque)
-        return m_opaque->GetBroadcasterName().GetCString();
+    if (m_opaque_ptr)
+        return m_opaque_ptr->GetBroadcasterName().GetCString();
     return NULL;
 }
 
 bool
 SBBroadcaster::EventTypeHasListeners (uint32_t event_type)
 {
-    if (m_opaque)
-        return m_opaque->EventTypeHasListeners (event_type);
+    if (m_opaque_ptr)
+        return m_opaque_ptr->EventTypeHasListeners (event_type);
     return false;
 }
 
 bool
 SBBroadcaster::RemoveListener (const SBListener &listener, uint32_t event_mask)
 {
-    if (m_opaque)
-        return m_opaque->RemoveListener (listener.get(), event_mask);
+    if (m_opaque_ptr)
+        return m_opaque_ptr->RemoveListener (listener.get(), event_mask);
     return false;
 }
 
 Broadcaster *
 SBBroadcaster::get () const
 {
-    return m_opaque;
+    return m_opaque_ptr;
 }
 
 void
 SBBroadcaster::reset (Broadcaster *broadcaster, bool owns)
 {
-    if (m_opaque && m_opaque_owned)
-        delete m_opaque;
-    m_opaque = broadcaster;
-    m_opaque_owned = owns;
+    if (owns)
+        m_opaque_sp.reset (broadcaster);
+    else
+        m_opaque_sp.reset ();
+    m_opaque_ptr = broadcaster;
 }
 
 
 bool
 SBBroadcaster::IsValid () const
 {
-    return m_opaque != NULL;
+    return m_opaque_ptr != NULL;
 }
 
 bool
 SBBroadcaster::operator == (const SBBroadcaster &rhs) const
 {
-    return m_opaque == rhs.m_opaque;
+    return m_opaque_ptr == rhs.m_opaque_ptr;
     
 }
 
 bool
 SBBroadcaster::operator != (const SBBroadcaster &rhs) const
 {
-    return m_opaque != rhs.m_opaque;
+    return m_opaque_ptr != rhs.m_opaque_ptr;
 }

lldb/source/API/SBCommandInterpreter.cpp

@@ -40,6 +40,18 @@ SBCommandInterpreter::SBCommandInterpreter (CommandInterpreter *interpreter) :
                      " => SBCommandInterpreter(%p)", interpreter, m_opaque_ptr);
 }
 
+SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs) :
+    m_opaque_ptr (rhs.m_opaque_ptr)
+{
+}
+
+const SBCommandInterpreter &
+SBCommandInterpreter::operator = (const SBCommandInterpreter &rhs)
+{
+    m_opaque_ptr = rhs.m_opaque_ptr;
+    return *this;
+}
+
 SBCommandInterpreter::~SBCommandInterpreter ()
 {
 }

lldb/source/API/SBCommandReturnObject.cpp

@@ -21,6 +21,27 @@ SBCommandReturnObject::SBCommandReturnObject () :
 {
 }
 
+SBCommandReturnObject::SBCommandReturnObject (const SBCommandReturnObject &rhs):
+    m_opaque_ap ()
+{
+    if (rhs.m_opaque_ap.get())
+        m_opaque_ap.reset (new CommandReturnObject (*rhs.m_opaque_ap));
+}
+
+const SBCommandReturnObject &
+SBCommandReturnObject::operator = (const SBCommandReturnObject &rhs)
+{
+    if (this != &rhs)
+    {
+        if (rhs.m_opaque_ap.get())
+            m_opaque_ap.reset (new CommandReturnObject (*rhs.m_opaque_ap));
+        else
+            m_opaque_ap.reset();
+    }
+    return *this;
+}
+
+
 SBCommandReturnObject::~SBCommandReturnObject ()
 {
     // m_opaque_ap will automatically delete any pointer it owns

lldb/source/API/SBCompileUnit.cpp

@@ -29,6 +29,19 @@ SBCompileUnit::SBCompileUnit (lldb_private::CompileUnit *lldb_object_ptr) :
 {
 }
 
+SBCompileUnit::SBCompileUnit(const SBCompileUnit &rhs) :
+    m_opaque_ptr (rhs.m_opaque_ptr)
+{
+}
+
+const SBCompileUnit &
+SBCompileUnit::operator = (const SBCompileUnit &rhs)
+{
+    m_opaque_ptr = rhs.m_opaque_ptr;
+    return *this;
+}
+
+
 SBCompileUnit::~SBCompileUnit ()
 {
     m_opaque_ptr = NULL;

lldb/source/API/SBDebugger.cpp

@@ -85,6 +85,21 @@ SBDebugger::SBDebugger () :
 {
 }
 
+SBDebugger::SBDebugger(const SBDebugger &rhs) :
+    m_opaque_sp (rhs.m_opaque_sp)
+{
+}
+
+SBDebugger &
+SBDebugger::operator = (const SBDebugger &rhs)
+{
+    if (this != &rhs)
+    {
+        m_opaque_sp = rhs.m_opaque_sp;
+    }
+    return *this;
+}
+
 SBDebugger::~SBDebugger ()
 {
 }
@@ -355,7 +370,7 @@ SBSourceManager &
 SBDebugger::GetSourceManager ()
 {
     static SourceManager g_lldb_source_manager;
-    static SBSourceManager g_sb_source_manager (g_lldb_source_manager);
+    static SBSourceManager g_sb_source_manager (&g_lldb_source_manager);
     return g_sb_source_manager;
 }
 

lldb/source/API/SBEvent.cpp

@@ -25,22 +25,40 @@ using namespace lldb_private;
 
 SBEvent::SBEvent () :
     m_event_sp (),
-    m_opaque (NULL)
+    m_opaque_ptr (NULL)
 {
 }
 
 SBEvent::SBEvent (uint32_t event_type, const char *cstr, uint32_t cstr_len) :
     m_event_sp (new Event (event_type, new EventDataBytes (cstr, cstr_len))),
-    m_opaque (m_event_sp.get())
+    m_opaque_ptr (m_event_sp.get())
 {
 }
 
 SBEvent::SBEvent (EventSP &event_sp) :
     m_event_sp (event_sp),
-    m_opaque (event_sp.get())
+    m_opaque_ptr (event_sp.get())
 {
 }
 
+SBEvent::SBEvent (const SBEvent &rhs) :
+    m_event_sp (rhs.m_event_sp),
+    m_opaque_ptr (rhs.m_opaque_ptr)
+{
+    
+}
+    
+const SBEvent &
+SBEvent::operator = (const SBEvent &rhs)
+{
+    if (this != &rhs)
+    {
+        m_event_sp = rhs.m_event_sp;
+        m_opaque_ptr = rhs.m_opaque_ptr;
+    }
+    return *this;
+}
+
 SBEvent::~SBEvent()
 {
 }
@@ -136,31 +154,31 @@ SBEvent::get() const
     // There is a dangerous accessor call GetSharedPtr which can be used, so if
     // we have anything valid in m_event_sp, we must use that since if it gets
     // used by a function that puts something in there, then it won't update
-    // m_opaque...
+    // m_opaque_ptr...
     if (m_event_sp)
-        m_opaque = m_event_sp.get();
+        m_opaque_ptr = m_event_sp.get();
 
-    return m_opaque;
+    return m_opaque_ptr;
 }
 
 void
 SBEvent::reset (EventSP &event_sp)
 {
     m_event_sp = event_sp;
-    m_opaque = m_event_sp.get();
+    m_opaque_ptr = m_event_sp.get();
 }
 
 void
 SBEvent::reset (Event* event_ptr)
 {
-    m_opaque = event_ptr;
+    m_opaque_ptr = event_ptr;
     m_event_sp.reset();
 }
 
 bool
 SBEvent::IsValid() const
 {
-    // Do NOT use m_opaque directly!!! Must use the SBEvent::get()
+    // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get()
     // accessor. See comments in SBEvent::get()....
     return SBEvent::get() != NULL;
 
@@ -186,7 +204,7 @@ SBEvent::GetDescription (SBStream &description)
     if (get())
     {
         description.ref();
-        m_opaque->Dump (description.get());
+        m_opaque_ptr->Dump (description.get());
     }
     else
         description.Printf ("No value");
@@ -200,7 +218,7 @@ SBEvent::GetDescription (SBStream &description) const
     if (get())
     {
         description.ref();
-        m_opaque->Dump (description.get());
+        m_opaque_ptr->Dump (description.get());
     }
     else
         description.Printf ("No value");

lldb/source/API/SBFrame.cpp

@@ -63,6 +63,19 @@ SBFrame::SBFrame (const lldb::StackFrameSP &lldb_object_sp) :
     }
 }
 
+SBFrame::SBFrame(const SBFrame &rhs) :
+    m_opaque_sp (rhs.m_opaque_sp)
+{
+}
+
+const SBFrame &
+SBFrame::operator = (const SBFrame &rhs)
+{
+    if (this != &rhs)
+        m_opaque_sp = rhs.m_opaque_sp;
+    return *this;
+}
+
 SBFrame::~SBFrame()
 {
 }

lldb/source/API/SBFunction.cpp

@@ -32,6 +32,18 @@ SBFunction::SBFunction (lldb_private::Function *lldb_object_ptr) :
 {
 }
 
+SBFunction::SBFunction (const lldb::SBFunction &rhs) :
+    m_opaque_ptr (rhs.m_opaque_ptr)
+{
+}
+
+const SBFunction &
+SBFunction::operator = (const SBFunction &rhs)
+{
+    m_opaque_ptr = rhs.m_opaque_ptr;
+    return *this;
+}
+
 SBFunction::~SBFunction ()
 {
     m_opaque_ptr = NULL;

lldb/source/API/SBInstruction.cpp

@@ -28,6 +28,19 @@ SBInstruction::SBInstruction (const lldb::InstructionSP& inst_sp) :
 {
 }
 
+SBInstruction::SBInstruction(const SBInstruction &rhs) :
+    m_opaque_sp (rhs.m_opaque_sp)
+{
+}
+
+const SBInstruction &
+SBInstruction::operator = (const SBInstruction &rhs)
+{
+    if (this != &rhs)
+        m_opaque_sp = rhs.m_opaque_sp;
+    return *this;
+}
+
 SBInstruction::~SBInstruction ()
 {
 }

lldb/source/API/SBInstructionList.cpp

@@ -22,6 +22,20 @@ SBInstructionList::SBInstructionList () :
 {
 }
 
+SBInstructionList::SBInstructionList(const SBInstructionList &rhs) :
+    m_opaque_sp (rhs.m_opaque_sp)
+{
+}
+
+const SBInstructionList &
+SBInstructionList::operator = (const SBInstructionList &rhs)
+{
+    if (this != &rhs)
+        m_opaque_sp = rhs.m_opaque_sp;
+    return *this;
+}
+
+
 SBInstructionList::~SBInstructionList ()
 {
 }

lldb/source/API/SBListener.cpp

@@ -23,15 +23,17 @@ using namespace lldb_private;
 
 
 SBListener::SBListener () :
-    m_opaque_ptr (NULL),
-    m_opaque_ptr_owned (false)
+    m_opaque_sp (),
+    m_opaque_ptr (NULL)
 {
 }
 
 SBListener::SBListener (const char *name) :
-    m_opaque_ptr (new Listener (name)),
-    m_opaque_ptr_owned (true)
+    m_opaque_sp (new Listener (name)),
+    m_opaque_ptr (NULL)
 {
+    m_opaque_ptr = m_opaque_sp.get();
+
     Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
 
     if (log)
@@ -39,22 +41,32 @@ SBListener::SBListener (const char *name) :
                      name, m_opaque_ptr);
 }
 
+
+SBListener::SBListener (const SBListener &rhs) :
+    m_opaque_sp (rhs.m_opaque_sp),
+    m_opaque_ptr (rhs.m_opaque_ptr)
+{
+}
+
+const lldb::SBListener &
+SBListener::operator = (const lldb::SBListener &rhs)
+{
+    if (this != &rhs)
+    {
+        m_opaque_sp = rhs.m_opaque_sp;
+        m_opaque_ptr = rhs.m_opaque_ptr;
+    }
+    return *this;
+}
+
 SBListener::SBListener (Listener &listener) :
-    m_opaque_ptr (&listener),
-    m_opaque_ptr_owned (false)
+    m_opaque_sp (),
+    m_opaque_ptr (&listener)
 {
 }
 
 SBListener::~SBListener ()
 {
-    if (m_opaque_ptr_owned)
-    {
-        if (m_opaque_ptr)
-        {
-            delete m_opaque_ptr;
-            m_opaque_ptr = NULL;
-        }
-    }
 }
 
 bool
@@ -365,11 +377,12 @@ SBListener::get() const
 }
 
 void
-SBListener::reset(Listener *listener, bool transfer_ownership)
+SBListener::reset(Listener *listener, bool owns)
 {
-    if (m_opaque_ptr_owned && m_opaque_ptr)
-        delete m_opaque_ptr;
-    m_opaque_ptr_owned = transfer_ownership;
+    if (owns)
+        m_opaque_sp.reset (listener);
+    else
+        m_opaque_sp.reset ();
     m_opaque_ptr = listener;
 }
 

lldb/source/API/SBModule.cpp

@@ -30,6 +30,19 @@ SBModule::SBModule (const lldb::ModuleSP& module_sp) :
 {
 }
 
+SBModule::SBModule(const SBModule &rhs) :
+    m_opaque_sp (rhs.m_opaque_sp)
+{
+}
+
+const SBModule &
+SBModule::operator = (const SBModule &rhs)
+{
+    if (this != &rhs)
+        m_opaque_sp = rhs.m_opaque_sp;
+    return *this;
+}
+
 SBModule::~SBModule ()
 {
 }

lldb/source/API/SBProcess.cpp

@@ -61,6 +61,14 @@ SBProcess::SBProcess (const lldb::ProcessSP &process_sp) :
 {
 }
 
+const SBProcess&
+SBProcess::operator = (const SBProcess& rhs)
+{
+    if (this != &rhs)
+        m_opaque_sp = rhs.m_opaque_sp;
+    return *this;
+}
+
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------

lldb/source/API/SBSourceManager.cpp

@@ -20,8 +20,8 @@ using namespace lldb;
 using namespace lldb_private;
 
 
-SBSourceManager::SBSourceManager (SourceManager& source_manager) :
-    m_opaque_ref (source_manager)
+SBSourceManager::SBSourceManager (SourceManager* source_manager) :
+    m_opaque_ptr (source_manager)
 {
 }
 
@@ -29,6 +29,18 @@ SBSourceManager::~SBSourceManager()
 {
 }
 
+SBSourceManager::SBSourceManager(const SBSourceManager &rhs) :
+    m_opaque_ptr (rhs.m_opaque_ptr)
+{
+}
+
+const SBSourceManager &
+SBSourceManager::operator = (const SBSourceManager &rhs)
+{
+    m_opaque_ptr = rhs.m_opaque_ptr;
+    return *this;
+}
+
 size_t
 SBSourceManager::DisplaySourceLinesWithLineNumbers
 (
@@ -40,6 +52,9 @@ SBSourceManager::DisplaySourceLinesWithLineNumbers
     FILE *f
 )
 {
+    if (m_opaque_ptr == NULL)
+        return 0;
+
     if (f == NULL)
         return 0;
 
@@ -48,18 +63,12 @@ SBSourceManager::DisplaySourceLinesWithLineNumbers
         StreamFile str (f);
 
 
-        return m_opaque_ref.DisplaySourceLinesWithLineNumbers (*file,
-                                                               line,
-                                                               context_before,
-                                                               context_after,
-                                                               current_line_cstr,
-                                                               &str);
+        return m_opaque_ptr->DisplaySourceLinesWithLineNumbers (*file,
+                                                                line,
+                                                                context_before,
+                                                                context_after,
+                                                                current_line_cstr,
+                                                                &str);
     }
     return 0;
 }
-
-SourceManager &
-SBSourceManager::GetLLDBManager ()
-{
-    return m_opaque_ref;
-}

lldb/source/API/SBStringList.cpp

@@ -34,21 +34,23 @@ SBStringList::SBStringList (const SBStringList  &rhs) :
 }
 
 
-
-SBStringList::~SBStringList ()
-{
-}
-
-
 const SBStringList &
 SBStringList::operator = (const SBStringList &rhs)
 {
-    if (rhs.IsValid())
-        m_opaque_ap.reset (new lldb_private::StringList(*rhs));
-
+    if (this != &rhs)
+    {
+        if (rhs.IsValid())
+            m_opaque_ap.reset(new lldb_private::StringList(*rhs));
+        else
+            m_opaque_ap.reset();
+    }
     return *this;
 }
 
+SBStringList::~SBStringList ()
+{
+}
+
 const lldb_private::StringList *
 SBStringList::operator->() const
 {

lldb/source/API/SBSymbol.cpp

@@ -29,6 +29,19 @@ SBSymbol::SBSymbol (lldb_private::Symbol *lldb_object_ptr) :
 {
 }
 
+SBSymbol::SBSymbol (const lldb::SBSymbol &rhs) :
+    m_opaque_ptr (rhs.m_opaque_ptr)
+{
+}
+
+const SBSymbol &
+SBSymbol::operator = (const SBSymbol &rhs)
+{
+    m_opaque_ptr = rhs.m_opaque_ptr;
+    return *this;
+}
+
+
 SBSymbol::~SBSymbol ()
 {
     m_opaque_ptr = NULL;

lldb/source/API/SBTarget.cpp

@@ -64,6 +64,14 @@ SBTarget::SBTarget(const TargetSP& target_sp) :
 {
 }
 
+const SBTarget&
+SBTarget::operator = (const SBTarget& rhs)
+{
+    if (this != &rhs)
+        m_opaque_sp = rhs.m_opaque_sp;
+    return *this;
+}
+
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------

lldb/source/API/SBType.cpp

@@ -40,7 +40,21 @@ SBType::SBType (void *ast, void *clang_type) :
     m_type (clang_type)
 {
 }
-    
+
+SBType::SBType (const SBType &rhs) :
+    m_ast (rhs.m_ast),
+    m_type (rhs.m_type)
+{
+}
+
+const SBType &
+SBType::operator =(const SBType &rhs)
+{
+    m_ast = rhs.m_ast;
+    m_type = rhs.m_type;
+    return *this;
+}
+
 SBType::~SBType ()
 {
 }
@@ -212,6 +226,35 @@ SBTypeMember::SBTypeMember () :
 {
 }
 
+SBTypeMember::SBTypeMember (const SBTypeMember &rhs) :
+    m_ast (rhs.m_ast),
+    m_parent_type (rhs.m_parent_type),
+    m_member_type (rhs.m_member_type),
+    m_member_name (rhs.m_member_name),
+    m_offset (rhs.m_offset),
+    m_bit_size (rhs.m_bit_size),
+    m_bit_offset (rhs.m_bit_offset),
+    m_is_base_class (rhs.m_is_base_class)
+{
+}
+
+const SBTypeMember&
+SBTypeMember::operator =(const SBTypeMember &rhs)
+{
+    if (this != &rhs)
+    {
+        m_ast = rhs.m_ast;
+        m_parent_type = rhs.m_parent_type;
+        m_member_type = rhs.m_member_type;
+        m_member_name = rhs.m_member_name;
+        m_offset = rhs.m_offset;
+        m_bit_size = rhs.m_bit_size;
+        m_bit_offset = rhs.m_bit_offset;
+        m_is_base_class = rhs.m_is_base_class;
+    }
+    return *this;
+}
+
 SBTypeMember::~SBTypeMember ()
 {
     SetName (NULL);

lldb/source/API/SBValue.cpp

@@ -44,6 +44,19 @@ SBValue::SBValue (const lldb::ValueObjectSP &value_sp) :
 {
 }
 
+SBValue::SBValue(const SBValue &rhs) :
+    m_opaque_sp (rhs.m_opaque_sp)
+{
+}
+
+const SBValue &
+SBValue::operator = (const SBValue &rhs)
+{
+    if (this != &rhs)
+        m_opaque_sp = rhs.m_opaque_sp;
+    return *this;
+}
+
 SBValue::~SBValue()
 {
 }