Reflow paragraphs in comments.

This is intended as a clean up after the big clang-format commit
(r280751), which unfortunately resulted in many of the comment
paragraphs in LLDB being very hard to read.

FYI, the script I used was:

import textwrap
import commands
import os
import sys
import re
tmp = "%s.tmp"%sys.argv[1]
out = open(tmp, "w+")
with open(sys.argv[1], "r") as f:
  header = ""
  text = ""
  comment = re.compile(r'^( *//) ([^ ].*)$')
  special = re.compile(r'^((([A-Z]+[: ])|([0-9]+ )).*)|(.*;)$')
  for line in f:
      match = comment.match(line)
      if match and not special.match(match.group(2)):
          # skip intentionally short comments.
          if not text and len(match.group(2)) < 40:
              out.write(line)
              continue

          if text:
              text += " " + match.group(2)
          else:
              header = match.group(1)
              text = match.group(2)

          continue

      if text:
          filled = textwrap.wrap(text, width=(78-len(header)),
                                 break_long_words=False)
          for l in filled:
              out.write(header+" "+l+'\n')
              text = ""

      out.write(line)

os.rename(tmp, sys.argv[1])

Differential Revision: https://reviews.llvm.org/D46144

llvm-svn: 331197

20 files changed, 106 insertions, 132 deletions

diff --git a/lldb/source/API/SBAddress.cpp b/lldb/source/API/SBAddress.cpp
index a3493d7c743..20c73590646 100644
--- a/lldb/source/API/SBAddress.cpp
+++ b/lldb/source/API/SBAddress.cpp
@@ -120,10 +120,9 @@ void SBAddress::SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target) {
   else
     m_opaque_ap->Clear();
 
-  // Check if we weren't were able to resolve a section offset address.
-  // If we weren't it is ok, the load address might be a location on the
-  // stack or heap, so we should just have an address with no section and
-  // a valid offset
+  // Check if we weren't were able to resolve a section offset address. If we
+  // weren't it is ok, the load address might be a location on the stack or
+  // heap, so we should just have an address with no section and a valid offset
   if (!m_opaque_ap->IsValid())
     m_opaque_ap->SetOffset(load_addr);
 }
@@ -163,9 +162,8 @@ Address &SBAddress::ref() {
 }
 
 const Address &SBAddress::ref() const {
-  // This object should already have checked with "IsValid()"
-  // prior to calling this function. In case you didn't we will assert
-  // and die to let you know.
+  // This object should already have checked with "IsValid()" prior to calling
+  // this function. In case you didn't we will assert and die to let you know.
   assert(m_opaque_ap.get());
   return *m_opaque_ap;
 }
diff --git a/lldb/source/API/SBBreakpointName.cpp b/lldb/source/API/SBBreakpointName.cpp
index 2205280b9e5..a6742e3b89e 100644
--- a/lldb/source/API/SBBreakpointName.cpp
+++ b/lldb/source/API/SBBreakpointName.cpp
@@ -52,8 +52,8 @@ public:
   bool operator==(const SBBreakpointNameImpl &rhs);
   bool operator!=(const SBBreakpointNameImpl &rhs);
 
-  // For now we take a simple approach and only keep the name, and relook
-  // up the location when we need it.
+  // For now we take a simple approach and only keep the name, and relook up
+  // the location when we need it.
   
   TargetSP GetTarget() const {
     return m_target_wp.lock();
@@ -115,8 +115,7 @@ SBBreakpointName::SBBreakpointName() {}
 SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name)
 {
   m_impl_up.reset(new SBBreakpointNameImpl(sb_target, name));
-  // Call FindBreakpointName here to make sure the name is valid, reset if
-  // not:
+  // Call FindBreakpointName here to make sure the name is valid, reset if not:
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     m_impl_up.reset();
@@ -133,8 +132,7 @@ SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name)
 
   m_impl_up.reset(new SBBreakpointNameImpl(target.shared_from_this(), name));
   
-  // Call FindBreakpointName here to make sure the name is valid, reset if
-  // not:
+  // Call FindBreakpointName here to make sure the name is valid, reset if not:
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name) {
     m_impl_up.reset();
diff --git a/lldb/source/API/SBCommandInterpreter.cpp b/lldb/source/API/SBCommandInterpreter.cpp
index c9bb8f65fa2..1f4f6b886a1 100644
--- a/lldb/source/API/SBCommandInterpreter.cpp
+++ b/lldb/source/API/SBCommandInterpreter.cpp
@@ -272,8 +272,8 @@ int SBCommandInterpreter::HandleCompletion(
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   int num_completions = 0;
 
-  // Sanity check the arguments that are passed in:
-  // cursor & last_char have to be within the current_line.
+  // Sanity check the arguments that are passed in: cursor & last_char have to
+  // be within the current_line.
   if (current_line == nullptr || cursor == nullptr || last_char == nullptr)
     return 0;
 
diff --git a/lldb/source/API/SBDebugger.cpp b/lldb/source/API/SBDebugger.cpp
index 97315d4c8fe..d8118def583 100644
--- a/lldb/source/API/SBDebugger.cpp
+++ b/lldb/source/API/SBDebugger.cpp
@@ -168,14 +168,10 @@ SBDebugger SBDebugger::Create(bool source_init_files,
   SBDebugger debugger;
 
   // Currently we have issues if this function is called simultaneously on two
-  // different
-  // threads. The issues mainly revolve around the fact that the
-  // lldb_private::FormatManager
-  // uses global collections and having two threads parsing the .lldbinit files
-  // can cause
-  // mayhem. So to get around this for now we need to use a mutex to prevent bad
-  // things
-  // from happening.
+  // different threads. The issues mainly revolve around the fact that the
+  // lldb_private::FormatManager uses global collections and having two threads
+  // parsing the .lldbinit files can cause mayhem. So to get around this for
+  // now we need to use a mutex to prevent bad things from happening.
   static std::recursive_mutex g_mutex;
   std::lock_guard<std::recursive_mutex> guard(g_mutex);
 
@@ -220,10 +216,10 @@ void SBDebugger::Destroy(SBDebugger &debugger) {
 }
 
 void SBDebugger::MemoryPressureDetected() {
-  // Since this function can be call asynchronously, we allow it to be
-  // non-mandatory. We have seen deadlocks with this function when called
-  // so we need to safeguard against this until we can determine what is
-  // causing the deadlocks.
+  // Since this function can be call asynchronously, we allow it to be non-
+  // mandatory. We have seen deadlocks with this function when called so we
+  // need to safeguard against this until we can determine what is causing the
+  // deadlocks.
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   const bool mandatory = false;
@@ -256,9 +252,9 @@ void SBDebugger::SkipAppInitFiles(bool b) {
     m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b);
 }
 
-// Shouldn't really be settable after initialization as this could cause lots of
-// problems; don't want users
-// trying to switch modes in the middle of a debugging session.
+// Shouldn't really be settable after initialization as this could cause lots
+// of problems; don't want users trying to switch modes in the middle of a
+// debugging session.
 void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
diff --git a/lldb/source/API/SBEvent.cpp b/lldb/source/API/SBEvent.cpp
index 17a16ffd048..65eb71c0928 100644
--- a/lldb/source/API/SBEvent.cpp
+++ b/lldb/source/API/SBEvent.cpp
@@ -146,8 +146,8 @@ void SBEvent::reset(Event *event_ptr) {
 }
 
 bool SBEvent::IsValid() const {
-  // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get()
-  // accessor. See comments in SBEvent::get()....
+  // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor.
+  // See comments in SBEvent::get()....
   return SBEvent::get() != NULL;
 }
 
diff --git a/lldb/source/API/SBInstruction.cpp b/lldb/source/API/SBInstruction.cpp
index 1cca8db2afe..eece5f6aae0 100644
--- a/lldb/source/API/SBInstruction.cpp
+++ b/lldb/source/API/SBInstruction.cpp
@@ -27,12 +27,11 @@
 #include "lldb/Utility/DataExtractor.h"
 
 //----------------------------------------------------------------------
-// We recently fixed a leak in one of the Instruction subclasses where
-// the instruction will only hold a weak reference to the disassembler
-// to avoid a cycle that was keeping both objects alive (leak) and we
-// need the InstructionImpl class to make sure our public API behaves
-// as users would expect. Calls in our public API allow clients to do
-// things like:
+// We recently fixed a leak in one of the Instruction subclasses where the
+// instruction will only hold a weak reference to the disassembler to avoid a
+// cycle that was keeping both objects alive (leak) and we need the
+// InstructionImpl class to make sure our public API behaves as users would
+// expect. Calls in our public API allow clients to do things like:
 //
 // 1  lldb::SBInstruction inst;
 // 2  inst = target.ReadInstructions(pc, 1).GetInstructionAtIndex(0)
@@ -40,12 +39,12 @@
 // 4  ...
 //
 // There was a temporary lldb::DisassemblerSP object created in the
-// SBInstructionList that was returned by lldb.target.ReadInstructions()
-// that will go away after line 2 but the "inst" object should be able
-// to still answer questions about itself. So we make sure that any
-// SBInstruction objects that are given out have a strong reference to
-// the disassembler and the instruction so that the object can live and
-// successfully respond to all queries.
+// SBInstructionList that was returned by lldb.target.ReadInstructions() that
+// will go away after line 2 but the "inst" object should be able to still
+// answer questions about itself. So we make sure that any SBInstruction
+// objects that are given out have a strong reference to the disassembler and
+// the instruction so that the object can live and successfully respond to all
+// queries.
 //----------------------------------------------------------------------
 class InstructionImpl {
 public:
diff --git a/lldb/source/API/SBInstructionList.cpp b/lldb/source/API/SBInstructionList.cpp
index 3edb9eae98c..29e0c96075f 100644
--- a/lldb/source/API/SBInstructionList.cpp
+++ b/lldb/source/API/SBInstructionList.cpp
@@ -92,8 +92,8 @@ bool SBInstructionList::GetDescription(lldb::SBStream &description) {
   if (m_opaque_sp) {
     size_t num_instructions = GetSize();
     if (num_instructions) {
-      // Call the ref() to make sure a stream is created if one deesn't
-      // exist already inside description...
+      // Call the ref() to make sure a stream is created if one deesn't exist
+      // already inside description...
       Stream &sref = description.ref();
       const uint32_t max_opcode_byte_size =
           m_opaque_sp->GetInstructionList().GetMaxOpcocdeByteSize();
diff --git a/lldb/source/API/SBLaunchInfo.cpp b/lldb/source/API/SBLaunchInfo.cpp
index 87396eb8c4c..aa1759ab3d0 100644
--- a/lldb/source/API/SBLaunchInfo.cpp
+++ b/lldb/source/API/SBLaunchInfo.cpp
@@ -148,8 +148,8 @@ void SBLaunchInfo::SetProcessPluginName(const char *plugin_name) {
 }
 
 const char *SBLaunchInfo::GetShell() {
-  // Constify this string so that it is saved in the string pool.  Otherwise
-  // it would be freed when this function goes out of scope.
+  // Constify this string so that it is saved in the string pool.  Otherwise it
+  // would be freed when this function goes out of scope.
   ConstString shell(m_opaque_sp->GetShell().GetPath().c_str());
   return shell.AsCString();
 }
diff --git a/lldb/source/API/SBModule.cpp b/lldb/source/API/SBModule.cpp
index 17f3dcc5656..bf2f8789452 100644
--- a/lldb/source/API/SBModule.cpp
+++ b/lldb/source/API/SBModule.cpp
@@ -165,11 +165,10 @@ const char *SBModule::GetUUIDString() const {
   const char *uuid_cstr = NULL;
   ModuleSP module_sp(GetSP());
   if (module_sp) {
-    // We are going to return a "const char *" value through the public
-    // API, so we need to constify it so it gets added permanently the
-    // string pool and then we don't need to worry about the lifetime of the
-    // string as it will never go away once it has been put into the ConstString
-    // string pool
+    // We are going to return a "const char *" value through the public API, so
+    // we need to constify it so it gets added permanently the string pool and
+    // then we don't need to worry about the lifetime of the string as it will
+    // never go away once it has been put into the ConstString string pool
     uuid_cstr = ConstString(module_sp->GetUUID().GetAsString()).GetCString();
   }
 
@@ -515,9 +514,9 @@ const char *SBModule::GetTriple() {
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     std::string triple(module_sp->GetArchitecture().GetTriple().str());
-    // Unique the string so we don't run into ownership issues since
-    // the const strings put the string into the string pool once and
-    // the strings never comes out
+    // Unique the string so we don't run into ownership issues since the const
+    // strings put the string into the string pool once and the strings never
+    // comes out
     ConstString const_triple(triple.c_str());
     return const_triple.GetCString();
   }
diff --git a/lldb/source/API/SBModuleSpec.cpp b/lldb/source/API/SBModuleSpec.cpp
index a1c08865c6a..89e8bef91bf 100644
--- a/lldb/source/API/SBModuleSpec.cpp
+++ b/lldb/source/API/SBModuleSpec.cpp
@@ -70,9 +70,9 @@ void SBModuleSpec::SetObjectName(const char *name) {
 
 const char *SBModuleSpec::GetTriple() {
   std::string triple(m_opaque_ap->GetArchitecture().GetTriple().str());
-  // Unique the string so we don't run into ownership issues since
-  // the const strings put the string into the string pool once and
-  // the strings never comes out
+  // Unique the string so we don't run into ownership issues since the const
+  // strings put the string into the string pool once and the strings never
+  // comes out
   ConstString const_triple(triple.c_str());
   return const_triple.GetCString();
 }
diff --git a/lldb/source/API/SBProcess.cpp b/lldb/source/API/SBProcess.cpp
index 23c1ede9983..f98670e07ae 100644
--- a/lldb/source/API/SBProcess.cpp
+++ b/lldb/source/API/SBProcess.cpp
@@ -896,8 +896,7 @@ SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) {
   ProcessSP process_sp =
       Process::ProcessEventData::GetProcessFromEvent(event.get());
   if (!process_sp) {
-    // StructuredData events also know the process they come from.
-    // Try that.
+    // StructuredData events also know the process they come from. Try that.
     process_sp = EventDataStructuredData::GetProcessFromEvent(event.get());
   }
 
diff --git a/lldb/source/API/SBQueueItem.cpp b/lldb/source/API/SBQueueItem.cpp
index 87ba73f9e6d..aac5844240f 100644
--- a/lldb/source/API/SBQueueItem.cpp
+++ b/lldb/source/API/SBQueueItem.cpp
@@ -112,8 +112,7 @@ SBThread SBQueueItem::GetExtendedBacktraceThread(const char *type) {
       thread_sp = m_queue_item_sp->GetExtendedBacktraceThread(type_const);
       if (thread_sp) {
         // Save this in the Process' ExtendedThreadList so a strong pointer
-        // retains the
-        // object
+        // retains the object
         process_sp->GetExtendedThreadList().AddThread(thread_sp);
         result.SetThread(thread_sp);
         if (log) {
diff --git a/lldb/source/API/SBStream.cpp b/lldb/source/API/SBStream.cpp
index 159ec07e4e0..d1af77a40fa 100644
--- a/lldb/source/API/SBStream.cpp
+++ b/lldb/source/API/SBStream.cpp
@@ -26,8 +26,8 @@ SBStream::~SBStream() {}
 
 bool SBStream::IsValid() const { return (m_opaque_ap.get() != NULL); }
 
-// If this stream is not redirected to a file, it will maintain a local
-// cache for the stream data which can be accessed using this accessor.
+// If this stream is not redirected to a file, it will maintain a local cache
+// for the stream data which can be accessed using this accessor.
 const char *SBStream::GetData() {
   if (m_is_file || m_opaque_ap.get() == NULL)
     return NULL;
@@ -35,9 +35,8 @@ const char *SBStream::GetData() {
   return static_cast<StreamString *>(m_opaque_ap.get())->GetData();
 }
 
-// If this stream is not redirected to a file, it will maintain a local
-// cache for the stream output whose length can be accessed using this
-// accessor.
+// If this stream is not redirected to a file, it will maintain a local cache
+// for the stream output whose length can be accessed using this accessor.
 size_t SBStream::GetSize() {
   if (m_is_file || m_opaque_ap.get() == NULL)
     return 0;
diff --git a/lldb/source/API/SBTarget.cpp b/lldb/source/API/SBTarget.cpp
index 9e9396df015..5d62cf81406 100644
--- a/lldb/source/API/SBTarget.cpp
+++ b/lldb/source/API/SBTarget.cpp
@@ -84,8 +84,8 @@ Status AttachToProcess(ProcessAttachInfo &attach_info, Target &target) {
     const auto state = process_sp->GetState();
     if (process_sp->IsAlive() && state == eStateConnected) {
       // If we are already connected, then we have already specified the
-      // listener, so if a valid listener is supplied, we need to error out
-      // to let the client know.
+      // listener, so if a valid listener is supplied, we need to error out to
+      // let the client know.
       if (attach_info.GetListener())
         return Status("process is connected and already has a listener, pass "
                       "empty listener");
@@ -288,8 +288,8 @@ SBProcess SBTarget::Launch(SBListener &listener, char const **argv,
 
     if (state == eStateConnected) {
       // If we are already connected, then we have already specified the
-      // listener, so if a valid listener is supplied, we need to error out
-      // to let the client know.
+      // listener, so if a valid listener is supplied, we need to error out to
+      // let the client know.
       if (listener.IsValid()) {
         error.SetErrorString("process is connected and already has a listener, "
                              "pass empty listener");
@@ -1543,9 +1543,9 @@ const char *SBTarget::GetTriple() {
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::string triple(target_sp->GetArchitecture().GetTriple().str());
-    // Unique the string so we don't run into ownership issues since
-    // the const strings put the string into the string pool once and
-    // the strings never comes out
+    // Unique the string so we don't run into ownership issues since the const
+    // strings put the string into the string pool once and the strings never
+    // comes out
     ConstString const_triple(triple.c_str());
     return const_triple.GetCString();
   }
@@ -1695,8 +1695,8 @@ lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) {
       }
     }
 
-    // Didn't find the type in the symbols; try the Objective-C runtime
-    // if one is installed
+    // Didn't find the type in the symbols; try the Objective-C runtime if one
+    // is installed
 
     ProcessSP process_sp(target_sp->GetProcessSP());
 
diff --git a/lldb/source/API/SBThread.cpp b/lldb/source/API/SBThread.cpp
index b34489603c8..def3b3a93fe 100644
--- a/lldb/source/API/SBThread.cpp
+++ b/lldb/source/API/SBThread.cpp
@@ -615,8 +615,7 @@ SBError SBThread::ResumeNewPlan(ExecutionContext &exe_ctx,
   }
 
   // User level plans should be Master Plans so they can be interrupted, other
-  // plans executed, and
-  // then a "continue" will resume the plan.
+  // plans executed, and then a "continue" will resume the plan.
   if (new_plan != NULL) {
     new_plan->SetIsMasterPlan(true);
     new_plan->SetOkayToDiscard(false);
@@ -911,8 +910,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
     // Grab the current function, then we will make sure the "until" address is
     // within the function.  We discard addresses that are out of the current
     // function, and then if there are no addresses remaining, give an
-    // appropriate
-    // error message.
+    // appropriate error message.
 
     bool all_in_function = true;
     AddressRange fun_range = frame_sc.function->GetAddressRange();
@@ -1374,8 +1372,7 @@ SBThread SBThread::GetExtendedBacktraceThread(const char *type) {
                 runtime->GetExtendedBacktraceThread(real_thread, type_const));
             if (new_thread_sp) {
               // Save this in the Process' ExtendedThreadList so a strong
-              // pointer retains the
-              // object.
+              // pointer retains the object.
               process->GetExtendedThreadList().AddThread(new_thread_sp);
               sb_origin_thread.SetThread(new_thread_sp);
               if (log) {
diff --git a/lldb/source/API/SBThreadPlan.cpp b/lldb/source/API/SBThreadPlan.cpp
index a19023f66de..131f8419590 100644
--- a/lldb/source/API/SBThreadPlan.cpp
+++ b/lldb/source/API/SBThreadPlan.cpp
@@ -138,8 +138,7 @@ bool SBThreadPlan::IsValid() {
 // plans...
 //
 // FIXME, you should only be able to queue thread plans from inside the methods
-// of a
-// Scripted Thread Plan.  Need a way to enforce that.
+// of a Scripted Thread Plan.  Need a way to enforce that.
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepOverRange(SBAddress &sb_start_address,
diff --git a/lldb/source/API/SBType.cpp b/lldb/source/API/SBType.cpp
index 80d48754c89..e199b7a33e4 100644
--- a/lldb/source/API/SBType.cpp
+++ b/lldb/source/API/SBType.cpp
@@ -88,9 +88,9 @@ TypeImpl &SBType::ref() {
 }
 
 const TypeImpl &SBType::ref() const {
-  // "const SBAddress &addr" should already have checked "addr.IsValid()"
-  // prior to calling this function. In case you didn't we will assert
-  // and die to let you know.
+  // "const SBAddress &addr" should already have checked "addr.IsValid()" prior
+  // to calling this function. In case you didn't we will assert and die to let
+  // you know.
   assert(m_opaque_sp.get());
   return *m_opaque_sp;
 }
diff --git a/lldb/source/API/SBTypeCategory.cpp b/lldb/source/API/SBTypeCategory.cpp
index 38e7cca35df..30414bd728c 100644
--- a/lldb/source/API/SBTypeCategory.cpp
+++ b/lldb/source/API/SBTypeCategory.cpp
@@ -341,9 +341,9 @@ bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name,
   // FIXME: we need to iterate over all the Debugger objects and have each of
   // them contain a copy of the function
   // since we currently have formatters live in a global space, while Python
-  // code lives in a specific Debugger-related environment
-  // this should eventually be fixed by deciding a final location in the LLDB
-  // object space for formatters
+  // code lives in a specific Debugger-related environment this should
+  // eventually be fixed by deciding a final location in the LLDB object space
+  // for formatters
   if (summary.IsFunctionCode()) {
     const void *name_token =
         (const void *)ConstString(type_name.GetName()).GetCString();
@@ -453,9 +453,9 @@ bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
   // FIXME: we need to iterate over all the Debugger objects and have each of
   // them contain a copy of the function
   // since we currently have formatters live in a global space, while Python
-  // code lives in a specific Debugger-related environment
-  // this should eventually be fixed by deciding a final location in the LLDB
-  // object space for formatters
+  // code lives in a specific Debugger-related environment this should
+  // eventually be fixed by deciding a final location in the LLDB object space
+  // for formatters
   if (synth.IsClassCode()) {
     const void *name_token =
         (const void *)ConstString(type_name.GetName()).GetCString();
diff --git a/lldb/source/API/SBValue.cpp b/lldb/source/API/SBValue.cpp
index b6f044c61a7..a270c0471e9 100644
--- a/lldb/source/API/SBValue.cpp
+++ b/lldb/source/API/SBValue.cpp
@@ -89,16 +89,13 @@ public:
       // FIXME: This check is necessary but not sufficient.  We for sure don't
       // want to touch SBValues whose owning
       // targets have gone away.  This check is a little weak in that it
-      // enforces that restriction when you call
-      // IsValid, but since IsValid doesn't lock the target, you have no
-      // guarantee that the SBValue won't go
-      // invalid after you call this...
-      // Also, an SBValue could depend on data from one of the modules in the
-      // target, and those could go away
-      // independently of the target, for instance if a module is unloaded.  But
-      // right now, neither SBValues
-      // nor ValueObjects know which modules they depend on.  So I have no good
-      // way to make that check without
+      // enforces that restriction when you call IsValid, but since IsValid
+      // doesn't lock the target, you have no guarantee that the SBValue won't
+      // go invalid after you call this... Also, an SBValue could depend on
+      // data from one of the modules in the target, and those could go away
+      // independently of the target, for instance if a module is unloaded.
+      // But right now, neither SBValues nor ValueObjects know which modules
+      // they depend on.  So I have no good way to make that check without
       // tracking that in all the ValueObject subclasses.
       TargetSP target_sp = m_valobj_sp->GetTargetSP();
       if (target_sp && target_sp->IsValid())
@@ -129,9 +126,9 @@ public:
 
     ProcessSP process_sp(value_sp->GetProcessSP());
     if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) {
-      // We don't allow people to play around with ValueObject if the process is
-      // running.
-      // If you want to look at values, pause the process, then look.
+      // We don't allow people to play around with ValueObject if the process
+      // is running. If you want to look at values, pause the process, then
+      // look.
       if (log)
         log->Printf("SBValue(%p)::GetSP() => error: process is running",
                     static_cast<void *>(value_sp.get()));
@@ -171,10 +168,8 @@ public:
 
   // All the derived values that we would make from the m_valobj_sp will share
   // the ExecutionContext with m_valobj_sp, so we don't need to do the
-  // calculations
-  // in GetSP to return the Target, Process, Thread or Frame.  It is convenient
-  // to
-  // provide simple accessors for these, which I do here.
+  // calculations in GetSP to return the Target, Process, Thread or Frame.  It
+  // is convenient to provide simple accessors for these, which I do here.
   TargetSP GetTargetSP() {
     if (m_valobj_sp)
       return m_valobj_sp->GetTargetSP();
@@ -242,9 +237,9 @@ SBValue &SBValue::operator=(const SBValue &rhs) {
 SBValue::~SBValue() {}
 
 bool SBValue::IsValid() {
-  // If this function ever changes to anything that does more than just
-  // check if the opaque shared pointer is non NULL, then we need to update
-  // all "if (m_opaque_sp)" code in this file.
+  // If this function ever changes to anything that does more than just check
+  // if the opaque shared pointer is non NULL, then we need to update all "if
+  // (m_opaque_sp)" code in this file.
   return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid() &&
          m_opaque_sp->GetRootSP().get() != NULL;
 }
@@ -1397,11 +1392,9 @@ lldb::SBAddress SBValue::GetAddress() {
         if (module_sp)
           module_sp->ResolveFileAddress(value, addr);
       } else if (addr_type == eAddressTypeLoad) {
-        // no need to check the return value on this.. if it can actually do the
-        // resolve
-        // addr will be in the form (section,offset), otherwise it will simply
-        // be returned
-        // as (NULL, value)
+        // no need to check the return value on this.. if it can actually do
+        // the resolve addr will be in the form (section,offset), otherwise it
+        // will simply be returned as (NULL, value)
         addr.SetLoadAddress(value, target_sp.get());
       }
     }
diff --git a/lldb/source/API/SystemInitializerFull.cpp b/lldb/source/API/SystemInitializerFull.cpp
index 8f6f05cd437..3831e4007b2 100644
--- a/lldb/source/API/SystemInitializerFull.cpp
+++ b/lldb/source/API/SystemInitializerFull.cpp
@@ -138,11 +138,10 @@ extern "C" void init_lldb(void);
 #define LLDBSwigPyInit init_lldb
 #endif
 
-// these are the Pythonic implementations of the required callbacks
-// these are scripting-language specific, which is why they belong here
-// we still need to use function pointers to them instead of relying
-// on linkage-time resolution because the SWIG stuff and this file
-// get built at different times
+// these are the Pythonic implementations of the required callbacks these are
+// scripting-language specific, which is why they belong here we still need to
+// use function pointers to them instead of relying on linkage-time resolution
+// because the SWIG stuff and this file get built at different times
 extern "C" bool LLDBSwigPythonBreakpointCallbackFunction(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::StackFrameSP &sb_frame,
@@ -262,10 +261,9 @@ void SystemInitializerFull::Initialize() {
 #if !defined(LLDB_DISABLE_PYTHON)
   InitializeSWIG();
 
-  // ScriptInterpreterPython::Initialize() depends on things like HostInfo being
-  // initialized
-  // so it can compute the python directory etc, so we need to do this after
-  // SystemInitializerCommon::Initialize().
+  // ScriptInterpreterPython::Initialize() depends on things like HostInfo
+  // being initialized so it can compute the python directory etc, so we need
+  // to do this after SystemInitializerCommon::Initialize().
   ScriptInterpreterPython::Initialize();
 #endif
 
@@ -363,8 +361,8 @@ void SystemInitializerFull::Initialize() {
   DynamicLoaderDarwinKernel::Initialize();
 #endif
 
-  // This plugin is valid on any host that talks to a Darwin remote.
-  // It shouldn't be limited to __APPLE__.
+  // This plugin is valid on any host that talks to a Darwin remote. It
+  // shouldn't be limited to __APPLE__.
   StructuredDataDarwinLog::Initialize();
 
   //----------------------------------------------------------------------
@@ -382,8 +380,8 @@ void SystemInitializerFull::Initialize() {
   // Scan for any system or user LLDB plug-ins
   PluginManager::Initialize();
 
-  // The process settings need to know about installed plug-ins, so the Settings
-  // must be initialized
+  // The process settings need to know about installed plug-ins, so the
+  // Settings must be initialized
   // AFTER PluginManager::Initialize is called.
 
   Debugger::SettingsInitialize();